From 8da430f5e802199c0fe7e30a882c29a02c51a5c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivar=20H=C3=A4rnqvist?= <ivarhar@outlook.com>
Date: Mon, 18 May 2020 16:44:03 +0200
Subject: [PATCH] add find_result_keys_by_name utility function

---
 _b_asic.cpython-38-x86_64-linux-gnu.so |    Bin 283800 -> 0 bytes
 _b_asic_debug_log.txt                  | 119738 ----------------------
 test/test_simulation.py                |     20 +-
 3 files changed, 5 insertions(+), 119753 deletions(-)
 delete mode 100755 _b_asic.cpython-38-x86_64-linux-gnu.so
 delete mode 100644 _b_asic_debug_log.txt

diff --git a/_b_asic.cpython-38-x86_64-linux-gnu.so b/_b_asic.cpython-38-x86_64-linux-gnu.so
deleted file mode 100755
index 0b131ad01b2da9899d913dedbe1a7ccd7178d300..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 283800
zcmeFa3s{uZ`ZhkI6lDgM6xl&)V`)cFG0-SbvB6NuL)mdaK&2E22gTANm2#S<sH|;g
zc1JtY$;`A+^U#@&+pLt1u5l{Jc4b=e-S@NBJ1iz<@BQ2V@B6On`(Jyy<X!i@p7pF}
zJ?mMAcfIdSSLNo9j_KCT<$SukPInPCU9OpIld)`U50i4avRxUj{qXk)*Wn`DkrNgP
zCo(S4N$2WH(3o|^GFho{<n`*~yGw?1waZC;4LaWyarG|M`kbp>ZXaa1hiYrxqdQ+y
z57Ff^4%JtuTnr$~)t;v1Yx6r_+l=d+Yn&-gDgMi#f-bHpnszx?%JNh2wYP-nDR1lc
zMP4u5PsCi#)hTy2%F)h$_hY)jHNn&u%`YoWea_X16xQ1Z|7hiz<0iY#Ei3pv|Ejd)
z_ZEB>xAwek%}<<p+3U2WKmKjSKg!cLG5z}=ePFj9OJ8#}9Q@4M+fsYi@8^zj#XNgw
zuVY6X+pRW_vY+7Jr}(!W|M>Y_UtC|9>sPq$z`r2=?Zm%t@$WnQ<L7()`$1Cr&ri7g
zZ169*{)&Hl4Bm_D?<UR5AN*q)*d5nc{M#4*&PXgw?sng!-)??k+S{WO_YVGi<<>V!
zmY=b>{f*U+ZW`6(Kjyc*L#{qeoizHFwlO!<?|;YM+P7C8bL1=69NcTv;pd+E+WaZ|
z{Ppd@Q<rY-Isd+u@7{jj%Gci;o;xi|opklZyH>7zQ+-&ttGZ&!b9GmpIe*v6cc<<?
z_p(!Z9Dm2Qkq582YM+<C{$<kUr{5o*`|~{|G20X8Rg^B8I^e?EONP%azqxPHfKBH$
zja+nS-R_mS!{Q2)Zz)Q>Xrr3D<LHFrf7nkQbt{__?Q;z}@1QO+OOA3mq2DQYc)zas
zBE*LiOLl=XlDp<lMZk1b@9Rf)E$>Cpbfy2TeY@rhqSV{>u&(P}d34u$CPlI53Dnz_
z{cTbB>4$f%KP5`L#vjqO{NBD@^Yf$V9}fAh?A#bd{%1_aUCG~eOxN{pK|FLNzZK)9
zEB+r*>Mf6=XMU7^yc0pzmHu1c&#w6AqVOxD*wY<;=qlcpM2Xwcum>*s)2Ck)`Li)e
zcV*{QQO09ZlsGSo5}%hu@&AKS`tj$#xLm#eWWCFk6J=b#8)dw_1RY(qt2|0vT^=RQ
zKaQg3kSOD2eR9|RRT+if5oMf?kD@;>%Dgu+iv0&g;j^Oj`>|2tWFz{kD}UY@#r`*=
z=qZd6&#y(9Pwv7z*;V{+jUt~CB|Z}l=sK=qqS(11O56^M(l0I0)0LfdQQ~%36hFiv
zPP&T!y;1t{*C_3ME=t^1Mv*@|iaoz#{q3sXFOM?b+oSZCCyL*8qP<<|zdefnZ=(2N
zXOwwhSd@A7>6otTeGwbOuKKZ8lzt3hTy)i6H%77ZnkfCUF-pCGDDt00X;*8MxP1ry
z@5;~bMXC4NDE*QarGF<!SvN;OzN>nFiDKvVQP!Q7D1OL@63@p*nIHN@;rpW>yXyB3
z;fJpHU!(YEDD-#L-i#>vJyGmmhf2GOtC>;aYH+l8j#BSd@LlP@C5r$5*0XE*6QkI3
zK$Ll7Q51WwiQ<P7qxgSZlzDqh6#dJi#QCSFx2yg-E6RPxjaWyzl3x*}y_ZF?=g=tQ
z_lhXvD>X`ckB>5M`=YGx{i5{OfGGCNjWX|@9EHClik-hj@xxJ3^sI>z57$TW&p}c2
zC&YB!Usp%rYom<cZ{g>z`u)Wy>(oV2?CBGwziOh4uO3m>&Eul@`GzQQz9R}h9P4IR
z?Ybq(e7ihKy`d<6csxp6{SZa}7k}w`p1C86o}MXP%byiR{+=l7PEnM3#v5f^Z;#U6
zpQHFWIf|WQqU=k#=D?&sea?*%{{>OT(LPbyyD&;zy&Pp+6i2ByJxaTJ!9QKa)ygRG
zvoXqj&BIaryd%mw{!0}3dob^HWzRlnS6BQOQPzdKqU>{c)7{lRAtuUvTaI<MtM&KM
zDE$Sx%XpZ$f7kV17^U9ZVPseBJu!;@2c!7yk0|luJGyIo6y&>V@5m_gd_xpHuSZ$e
zZjTbTpFqC1E6G(m83Pla2Kno9d1c%k=xTlp0f~=u%>KCSyZX4=^0a)i<hooN;OB!}
z2e_L4f{O6TH2irG6aD9Q*1t1}d>_}Avot@z$R8~8TaqjFLe0Z1^0~t3ccp0kaEpA#
z$+~c$tMO57r{lw&5<h)hyT@ofs7^j(;<cT%Mo*dHzeRD{*)m1TuhiAJM&mhyw5z`+
z96fo)&Ws2<OJQek7yM@IabhVO0ZRSJ=V<-<ugldadJc5ezOL<u+44CA1zB&xvASM}
z$>$Df7xX`^<uTmk^Sbdvf$1-YZ!z+{p3(B?Zuw+O|MqdkxjXx3jq%$S<2Pr_-iG;;
z_Oz_f_8frr@N*RmV|%^Eek|YeNi^+kFztQK@ZX7@eO&5HU9Y2mr;NJ;T$RSp+FF<E
zYs^2?f7=V1G1a=7Q4!;3N`(FYfc><y*67JH_3rJZ`8Lz<DTW_v;yhsd=J@9|ske`-
z-o&TV?<p`_`q9M6lSa=V<NpS30Pu0-mto-0o@~>PPaF9~;-5aQ+KBipHvVaf@Xr&*
z50%Cbj{e7CKlLX^#3vtu(au8Se`kD+IM~=@<k5Zdxx>h(8hK|NT_@|*0j|b$-7eD%
z*K@}ImB#;$ewW8HeO5)eXSTPf%IopCJb9DGdP+*GN~f32_Lf#n8ar}kMS1C@qNy`W
zbzavwp5mG!&$P1gqM2ovm%3(_O`Yv6DL&zZlV?|)Jd|)&I5oYv*fX0bjeN1@J?EFq
zESTf+oL@e7mTOk&tXUOvP~G_xy=kX<Jl+{q6>~jPi%L92GiO#5&!IqZ<vhtBl<MTq
zEG?hzo#831s;a0eIIEaKvrD~b9$Hp>si%0xrJiX;Wi#2{ni@}KY1QlsTI-$XnUm`B
zOfH{WR$k(nP&&JM7Hb|ic-k!QpgBV`%F5vd2&Sb@Et*|c>?tYo7Uj*!9a>U0z05m1
z_umjrpItV+oRZ=rX+n{=)KgkhTw3WZt0;$xNqJ~#23t6%sH&`}-0LYSE-sxt+msOp
zuqH?iuBtBgmd!$WHgx2mT((uKo>o=bNv(&jj%=tndRCXpMh(hk7fkdH8sa#$qT1`J
znC7V}DxY5Jfk#l;<z1GAArsDmedw;@nwqq<v_aZkv%OVi<<s+uVR>5djG`)!x2gz!
z%PY>EScE^h;=qaCjIxT^=;7I=L-NYYyd%@Z5UA_Sj}l(H(OX(mhTf%5{-<?jdd7N+
zt4h%cxf5p56)-N-Y4Oa8>FDKf6v2K3mTS)J@=7$sJIw{6cvht@l;&|4&7R?zI?r1=
zyWp%jqHEk)u-bzW<VCO{It!}USyiPoC|OxCv#fYt+7K8}URqjW=-gQ>Db1RSVOQ=c
zF7g)7Ficgc>3zvBMU2|H)2oZBFf58Mt1hcT*outis!C^;!k;cr!935XQi(cx>tBR*
zT1I8X+_Y2=L$+*MS#eQ$$-fojY3aILX-y?&i}HVOU`Qd1Lq-_t96BV|RWNUId0BBq
zNvS7ic5XQnB@-orkTZgA1|LC8<b+c&FSn}7GZIa%LV9Gytjd|CHIN-?l15;BadCB3
zRcQ&}=$REoUeBa?l`PDQCvWz|>Zx8$<X4nWNAbz!bVO+hAyw2AO9|9f!FpIHI6aKV
zveQaugC18sYicR1nNeDNX$KS?|8cw)&88(7V-ts9jy`|VIZjWe4VqR_H49CVkmYci
zlovJ6Q$4Gq#9KBPky2e!Hb+wbGA0HMzPz-m!c$R&@SWSyU4sXiu{#uVa?#9E3|d%6
z<0g7Dt7l`nC@L=X=2_!2qr7@nWp#P6R|fusvnF{^z-x*#IKw~>^nYntTIvk+vNaQj
z6*x1<zX<mzP1BJ$sTx7#8CN<NeK>yVC8fn)&q$0Todh?k42;fpf_8LO#Vj43IprlL
zFip{k@P)T@7Ru$#s;t0Lt1n|KN~*E4B4&#!XCvh~v(#HqA&X9@;aoHoWwdXx9?il+
z>n+7(jln&-Xy)uvR9an(eBen{)ebD4eHjWB7ft0tg8nWkX3x*6p2<YPynL+irU4S~
zVm(Ha$LnO~R90ffp><|NQDjs_H8ukbbf?*)N;y&|Pa2&8Qrt4Kq8#&Ixh>S;8wgqc
z1e#cSS#@c7aj8dKF0CAt?o7yB6{j(3uvB91n>mwf6hb9(B}~&RVHa5@nq-mfynLc=
zr)6d)2%F-J-Y{XhGmOzu(xLSEI81t`3)qu0XL7p~o&fU7u?0c%#$qb3C~@YT&S>Ol
zr-@>SZs8D5nC04-HrO))7tgGs@}lXbRe9%+%cz_;72B4yw4r*vNlWAW1ut>yhCM}w
z<G8%hSSE{gC+3ypUXq(TCwB;Dz>?f?6Vp6HXJDS6S(-aF7qbcM@XW0$LeE#_VpbmO
zRF^ve<Jyx`K2Nql7`dZ7=!6W<SZ$4`0tJd>Khr6g#}&zbYSP4lNE1vqp4!n!ZAR6f
zj4hZr$dk)eyR3Xp#idxaF>Q31GX4^y>0h|(PX_$+<_(S3Jj}2Yqt39%>!O{L{?sIx
zj5!?s#gbi9G_`C_8h5fzcX^~6%gU!!$b|l9!P#Y=;+a?zA_OOn!#-wuc{P=$4K6R8
zt9Q&r-ioR`^f@cd``03!tK$y5%et_EyF{xDr#hD$l;-iwnH9xS#!goo-t)PEiWu8N
z=FTYchPQ;y<_b+UyJea<y|mmj$1CHm46A=${?s(YcB&_BkY{Z5OmCT|sH&=HUS7dy
zA%}*`dWtJ5E-fp~9gm3v(j7{XfpN=eHE&F(!GlF+4i*ErbRuG;h<|f)JCC)Y9(X%<
zf@n<ljK$52hXrJZ3(Hb-$FOLoXW~c{&7GKwzjMY<O7)DNl;+8uJahacPp)S?DmCqc
z0hag}7V)NgxjZ4~Y^gnMDAx?k3ZB_!GR>PcCVy5cWOK3K^vo%nUFLPh&%|*a6w{+7
zyjSgL`G4K%jpEL<|GM*kXLJtwr|y)Snab*_QUq_6x4H<o?wG#*G>iXvCgmWm)O)DT
z^CNZ*|7XK}sOKDW|2`YT9gDOX?DpFGZ%-e&SntQ;77?cy9!_akvW@ex68~FM!&(2q
z)Zq3^JnR3;)bRh3ucD0m|N5$nB`3<Dc6`NMcxK1h7mxDfIHkNu4*rT~RAE4u6v<&A
z_E{LpQT8)9Jdz3FUyDqXqb3n{Qvb(if{xYnf8Rc0WJTq?f3}anwz$ik1h>oo)_j3&
z2X+=w*1jnHTHu*D>Ho@n@&7-MM%kSG*Q5VzyZcXLG|D{fc+@^Mn>`Qr$g?_5%`hW$
zOiSh@oX;e1o|Be_=LFMndr>q~jz-QcExNR-bQ+INCX`OYyn=@of0n}GKovx4<S>QD
zi97&_I8ZdlAkI+&j$|A`bK=-ZfHR|g>lxVu``|A!5B6nNmX#Kl&Mm_ULipB(Cq^B0
z@aU$%D<_*c=^Rl#Z5qx1tg}v>Vd>K?7auji8aVAgIeh2gLU{?#Ys`a)|EUr=m#8YO
zoQWewoSus!91x4ac!r}-zV-R+XgM9lLC>TaIP%A7GM~LT2gNow3dOvoBY8et&OXz5
z9xraP`5Xz_*#8rY=9KE3&LY$KsL3g$E16u5^Wfr3OH0tbPVpRlQXkfEW?sG)hRmcH
zWwR}V!uqv<K4|2L^XO7O9nh`A^D1mKd4AZ@i#c9zmFcE1jpr1dXnpMH97UP3WA#%4
zv_eik&4Cxsqu|q`l6f7qAP_pKlas`V^G=B)t*Ilvom0*~ADf2zNpv|Sa06aa&8IE@
zL8J}s2s2pj)C|*kIH|{F$Eh0(%B}g&>fyoEtZK$pM<_-d`RV2wHyh`{rh+OSn&Ang
zocZBo7|*^uo~a%_Xhb&8g3rN$JD(AvyD=p7nXxk@O(%|&M_Gd)B1f;rb>RpQ()5iv
zo5izJBaEQuA*K<Ao4HkxGpT?75#A6y_ASZfP?nQWFN~a7ItznHp55?RIvi2Xk?H@3
zdN|f)*7y%BO|KGD!z%vgZOyE#<^w-GP|jr!nI4@`TFFUMyel)lesV3(n(!<)yxVn7
zu5q><<~)_&s<gqKpnj5)YIap=|3X?$w{>_-lr>F<hdx367iEXco?BFjgI%c$%ZGg)
z$$If<sThwbtL5Q%E}F<7oS+{-J5fmLoT8c4r8bdQUQ$|P3_<U63dzSg8-}t$CgR6p
z2_CK260A_Cnunbo-odc{SM7Jqf~txtK9ZA1bIx$bXmEzRemYuGisSR?e3{`tnNx7w
zjV%KX;W5;;hKQp|>AU}6vSKTo$0>O3h({^m0o?hyXUBsjG!+jX@a&JTT%Z@s+XT`{
zI_<$!GpPz|Bm))|jIP3AJZF{svhq^>loD)s4azN_jnft|veH3pM0FWXPUR_%P@JFi
z3dILI)>=iKVMdnB@KPeHu2A}sJH+@9!;Bmg24NFA)^4W*jf9cUo9)c3(8J*2!<GuX
z0Kv}848I~`J@M%vAvEb6TM8<STG<b9TZjD|o|XOU2aiKBGD@dcRaEnNe8tR)D&C7a
z4+WyVGm<ux{qR37m8Oq?{{3nO&5bA_PrlOhOB|&#KzNddp*5(aViq3L>0L1WBc%N%
zO_;Rb1aU~5Ib%;$h8Ga3rsK64Y@5!^&l@q)Gw9?&C#Q$gL&B*vBu9?)3_f`<UjEUk
zRJjg0IrU_uSa`}5<PSM{P-mEy;X+Q%h&)dk3TN72kOexaKy6l;!JYC3rP+CDosh9y
z8-jPO%!`Fc={KtQ`jvhcE=K>t0ttNhCK}&zjKgm?nD64d_7~RW>WMeL4nP_&f8m2y
z#*Ee&$=9s;y#|qpfn*HiDCvB93gaNW9*56?^4EC>u0vXDq~*@PcuDc?%s5z2{mz?w
zRAF02ZTQ6isoT-4-!9|3k=kOGVI3X5>8RV~I#{HfH$Iu8?O`oij&0GUiFGZyMnLhR
zwqhU41N6v2u%4d|E9~+*Ck8(;@PGEd5>!O*CF5Up-!ggAa-4ZVu^XafzRAzVwNF_Y
zx+=kSKJr;+=}otxX$QJW4A$ijaM|U{t@1^lW1)XPSA~%;ICdVIysvAX!G-4^hx}OA
z)xi98gU2T0>hx~q?!Us-2fO@6eum)Qt~(5#_wG~B7w>w+;3~nrTq_KI|EWvy=3r0P
zdV@=({Qj=D4W2FXajwq{zD)A>aqTqtheLnI8@4@MzZzUE^4(qg_SZIg2i}Y>jdAq>
z=EwQn5Z%up-WS?cV17@;;hW#p{FDg3@jcDYh~SgWdykb7eCh{Uz9xdNH}6H)M(_o1
z=r>xIMDUK@Wf6RWc^|bQf^Yo0u6KC^U-_8U-x$HyntE48@Q&W52)@SD+Z@3sncr90
z62Uw2Z4ta9zdM3=<P*$$uTH-VFz?4EN8wYW@YzxLf+&1p6uvSFUmJyA63H9?G(_^I
zU5!!rEfIWzc|X}@;?D6;rQrue@C}A{NASCi-r5MhDOb<EOCtD|0h(`$;G4{Q&YL6n
zW}|;g1i#YYmI&U(A8x@%Mexlrn%^D4S6-x7%{cS@1IG_7#-4---mxb+f_E7_Ad)xs
zq(<<LJ=qa_y|Jetf_FWl?VJ+9JNC?o;N1pSM(~b*Y9e^Yo+S}{qp@dM1fOi|SsuYR
z8GdC1pKZRsusMQv>`yiE>-fLT$Y)3JsZJb5@Q$7-5qyThg%P~thZzyP<A<6EzQFil
zc?6$2TE}x^1fMWa^D86x!WT8aIf8F9?P`nU&G#~r%zWwiC)s@eA|rxVru>u$zHo((
zpBWK+gW)S9_yU7#Blu<`za)Y$G`Kl}cbV@Os0hBv%mZx^e7)i0%sl6`w_u~TKOus5
z=K16ZzShX6M(~Y>&xqh%2D>BpWFub?!8`F*7{NCg|IdizKh^zS8NsJ+(|n=%zLe8m
z2RB{NL*_GwfB8l2hs_au)9YGKa|EAl_=Je>6=fSck|TJ>{_F_eX>XI6k2#zE4gZ{d
z+-8gaLM+yQoN|<3V9Cdsc{q}HzJC+RJM(=c@65ZAyfgnr^3Hq^$=8~Gi{u@DMDn|%
z$UEa8Qr?NvNWR|0e<bh3V<bPo^jjqF^k*dBV)e_1R=>=!{BQHkR=aGz!Lrll+s5no
z<o%G%JKx8mJ-JrDJNt!5zTT`0k$giGzA*|vz_Q=2cS{uBnJ**jb>_cFezWBVTfegp
zjg)V*{QsTh{{+kbdn`W5;{Rds$riuD@@Il&kIiRT@~xJhLW}?1;%h9Pzmw;D8pd_>
zug%w6@=F|HT-&1X8CHMU^0iU;mMDCs)sMEG-IgD0zQ!6aHs4^`X|{&aiscsntJSVX
zi~q{vm1SqM#kX1fT=333x!dBECEs9;Bb$%2+KZd#@F&6Ie+skso}k5tEI!%ddsupw
zSo|lJe7(iLVetdZx<C~+-(bnNTk<QdcG-N3CI77@@3Q)lzvbwB;w-++A#ojG@n2f}
zGK;r<-qh7-@!weTD=q#Hi*K^{-4@?s@p~=4(i$&%<mk*Ai;uPBYc2j$i(g{#pILmp
z#q%7``7E<|9B70;%PszgFpKXATfFn#PiC*Qc>JV8_|s(ZzlB+sYqQ0tSbVd^pJee{
zEPjZ^w^)3-#Vd>F?{PYxHj6*aA#vSp@mUt{vf^-?#m8Cvc8gE2_%RlrWbr>*e6qz)
zwD<uQ|Fy-ZTKvTppJDN(7N2eLL5p`=yt&ns+yaZQwB)B){1p~oX^m@}FSO)8x8!G7
z{8o#vwD^S<Ut{stT70d=UuW@4EdB<IuebP{Eq<BB|JCA`Tl{kt-)QkKSbUSkueJEi
z7QfEon=PKd73+MqSo~WKiEE3+n<GNWRTgiK6ouby@gG}ymYID%tHe)pgg*@y|5%vC
zx?uHhzQwyO{&9;hu=o=#eu~9EY4L>?|GdS|u=tlPKB+*@jy#38+~!KQczs8s3k|S%
zeFvoZREy^x)cIssymQjeyljh)bA)kqTYOK8FR=InEPjf`;{ZMUDYW<l!>r3S!{YIi
z5#djz#XEZhX4Y7|e!8KH)LJ~BcQ~IV7Jslq;#zO<eJp;N#V1;PgT>>gD#D-T7Jq1%
z#X4f~_(_5AXQjm-5oTSkCW}AP;x}9TQ5N59@y>5hFnf!|CtLC@7JszGD~mtI;@d3#
zFBZSs;`>{?>+FuWJ=WsmEdDr)Pq6p_7N2DC11&z;;*YoZ0TzFP#iv^Q$rhhs@uygP
zw#BDfyxZc_EWW_v2U+|Siyv(9g%&^5;%8X=sTN;p@fj9hWAT|5Uu*HhEPjc_54ZSw
zi$C4sms$K77T;j;*%rUt;&Uv%(c(u~{7Q=-Y4J@KKg!}aTl{E?Z?^a|Eq;r|yDh%O
z;`1zCS^QZR-)8Y+Eq=GfkF$8!gpT+hZ}D*!UtsYG7Js(ICt3Uii%+)rNftlA;wM{t
zs>PpU@fj9>uEl3t{1l6KTl{$zUtsa)Tl^G@zrf-PE&f7_pJDMAS$w6%dn~@j;tMUl
z*5ZpSeu>3TwfK6AFSht)7GGlV4HiGm;+I?ebc=7a_!$<z(&Ec3zRBV*vG~mvf2qYc
zTl`Fm-(vBzEWX9!%Pn46e1*lgS^Q-dzuV%gEZ#M-BmQSwe4NF5Ek42Gt1Ujs;^$a=
zvc=a}`~ZueXYr{Pf4RkHSp0m8&$jq0E#7VMS6O_4#n)Q=6pO#w;tMT)k;Tuj_{A1q
zY4LRyUt{stSbVL;`z(Hm#rrM3-r}#f_+=I!u=oaxztQ5CTYSC6H(LBn7QfQsZ?X6$
zi(hK-n=SrUi*L60+bn*I#V@n?7K^{#;+4hUVexGif2YOow)nd&-ZiNs{_nQ<IE%l>
z;u9?XUW-q%_y&tlw)p!jet^Z_Z}F)X|A573Sp0()pKb9ES-jigAGY`ci(hW>Q!M@w
zi!ZeJM=gGa#Xn*3l@|Y$#n)JTqs7-+{L>b{#NwZ^_<D<f*5a30{7Q>&u=p1(e!0c3
zviL@ef63xkTKsB@Z?gC`7QflzU$OXRi*K^{Ef&At;#(~KRf|^^zro_$EPkWK@3#0&
z7Vk38>GlP;+2Z3Y{xyqFu=v+4KFQ+WwD@F;f7{{*So}K{pK9^%S$u}Ye_-+17XOjO
zyDk3j7GGfTTP*&+$^UxbzaIFn2mb4U|F=ExWBgHj+>5@AbNgdo+uq&fu50qfv^TpK
zy&9)i)%Nr+K)3h*3V-AKWg|r_cY48=c6|D8CGG|<1e*oFM;t@kB=~jW?!=9P*Aa6Q
z8Eg=|ia3_IUhp%-`w-U(ew3KYZLm`CeZ+CZg@W%O-jBFI@Xf^g6K4y)j<_drs^Eph
zJjx9w3%;DV7jc5%D&hl)U4kzmjwf#W14RF+#0kVLg3l-JP24Pa0`Wn_O@hY|A57dR
zcm#1D;s(LPh<OAXtQS0p_z>b+!N(Kx$Te6g_!#0O;zGfFi4P+#5PT4EU*c@R`x75d
zoGLhm_z2=;!F#p=A4!}bco#8`V1q8fJBj-dxBbrce?go~+#+}@@zKQ1g5M)PhPX-a
z>%@N{ZWO$ZIEA=D@G9c|#Px!oAwHJ4R`8?5#}QWwzK?hSaiQQlhzAlE2)>#4c;alq
z*AbsUoGN%B@rlIAf-fgNi8w)U74gZ$F2R=&pF-UBoAf_%DshY8^NG`ln*~oG9z@(E
zcntAi;zq$Eh=&k22p&e9PFyc|5b;prTEWK?^T;$<Dfk%T4B|q;eTg%P3j`lTJd8M7
z@czWZiBko~5T8bzEO^gnz*)ozf_D+~s5Iyjyp#A0;<mlg|HRqEErPca=MXmwevfzr
zag*TJiANGQ3SLJ%inu}WD&kz?dcn^Sk0!1a{3!96#Fc{YBX$!P3ciClkGMea&BSAf
zvjtyAd=_!4;DyBb#L0p$Cmu_jAh?Qn9I;FACB);2+xAHR6BiJ-2tJ?qY~p6Y6No1e
zHwhj?JdwCj@Cf2b#0`Rn5l<$r7d(jg9O7ER#}o4iGgvA37~(0!g@XGMpGRCE_#oo*
ziL(XoPkaG!s^A#n3yG5j@A(w?BH{$WyNE9)b_w1|>>+OZRr;T}khn$gR^lS!X2I_f
zPbF>={5o+laiidM#3jTHf>#lj64wiUhIkrrt>8zArxRBSzK@s-P_R(&9mHkC1%huT
zzJxei@O8wO5~m7YNIa7`S@7k=vxpM}R}q&Jy98fCTtVEnTl$~4lDI|i`NWqIHw&IX
zTt(a@cntAu;zq$Eh`q!Of`<`T6W0qKL_CMMR`Bt}bBQYjA46P2Tqw9N@jT)J!3Pmv
zPMj@xf8r~MQw7Hm&nHe6yyp|(1;h!0cM)Gn>=L|__$uPIU!?zuYl&L~ZzaB(xLNRf
z#0!a=1iwzah`3SkI^xB|4T4t@*AdqXeunrO;#$Fv5?@PPDfm9(CB%h-?;!RO7YM$Y
z_&VZj!PgP{iBknHB)*<FS@7k=0pbL~Rm3+Cy98fCd?Rt&&(i<I^~5cL&nLc#xLNQ7
z;+u(^1dk!Ug}71h2;!y04T6Ue-%4CBco6Yz#I=HtC;lsOrQl<Tmk}2V?n`_-ae?52
zi0>fI7Q8?4oy4hvV~Fn}P8PgpEAZXK34(VK-$U#Yyp#A|;<lfp|A`xjTLf<<{u^<#
z;P;5{BW@D>I`RF)je^$^KS10dcop%3#Px!oA%2LsR`8?54-;1k9`-?Z*EITHJ`>%(
zy>9<iN$$FKZ>%~BGnU&woM4{|WInrKy*m(l?HkzH`d6nY6mk0&r?l`oe11v+ii9x8
zAyQ&QmUY)6^}G&Woze_ZNNvzkr#p&bj3QnkwNgvntEG~R6#w7PtS(ig=BH#p(R?lP
z)9c!zCEc`0Ew8X>07TBCh_6*WjqL|4d)<is$@uuiqtGAfc!&pwAqClcqRS>x_79Bc
z;DJaLypjNu)#>PAcc9n3_@7O?{pri!$0d+>*z4V3_9m$N^)GO>JHC7^|7@NXKXYw-
z?|s#a*cRkW5(SeB)LwLoJCOcW3d*98Z-e?++Z{utfy6s8l+hZ9y!IAFa$Twh3i5of
zvW-V#h~@iss12ZiUrwS`%U~tRMvzjC+viP*a|dRoB&h3IogeT;h75{Ok$+Jm!3m3&
z<B}g3m6GaSyE~SpvR9=tCy@Rv?OUX}xqZl0xB1z`?^(%Nx<g9dM81E1N<yBmM~WLN
zlHHk`&>3&SK(yjROi<8r2&7nO1$G9;vPq6*yZ%AT2z{+DGTvdCwk44M5Nr33h;yG1
z<G-be7OmaggQjHrCZ(jV;_gkwblCI)902z(kvRIZO&Qvz9BtDuNYSQaV3XSqmAr?G
zcL(M}F@hNF`~x?1b>DeunEDMpPU%S^4c+K5tGS<<>^iy`;wMqew;>b~-*lFJ+Q^<~
zWV<=C9et)g`;kUD-9>j~!!4^u(k}mK_+uY<bu+?D91{PO%JW~#zRWw}TK1*xMz+Z}
zGo^qLkW8!o?hAL{_2P@zizM*przAVwm#Vw3mjrm?Ay{uvQ9PvB_+QZH@he896rR>z
z-NU_TGkdtZxUn_g_f31Bb*yBN%q381T5UAGgw|3=F}oXLJt;;Hshf5&=h6Xc0J{$Z
zf%^}N)F2~|v85-ec}Bx!xT@c1KV<tD+0_z`Str3IY9e;EYB&n3pE+)KViBoVCpfjN
zGbOi5ZLR7c$=IR#Qtg8#bB)O?g<9zrbr!_niWBK`JzfX01%cQJbYUPdw2&dw%7F^8
zM38DTl$h~43;oH~CyKc{RA74yrB$q$9ebeG@i25iO7}(jyRSjVV(4JO6B!UF@Bs}A
z#D0c6R63_qr41}FQ7qq~PB1mxFSu2OOfzo*uGdYf`9YfW$T8BSJl`gDj+oQy%*~=b
zNz6eLFe=h}f>S@!J^qpCkf!RaeBUqX!#0?g8LB=*U5bdw^PiTY`|2$*ce{EX`ELK+
zyd%!f{4&1o_8#aOuCHc@ZFBp!w>O8L%k$?_skfK#`J7@}+ne(iZAcC^xP9x@NvJr_
z|BA%6tXMNyL10Y{6sv4}7s&0;ZKQ$&-GK!S9pg98w=F2kNMKC{MH49+SThCbJl}S;
zkCa?f$yK1PJ-%*F498d93}XKpo|B~g><;wVfFb2lk4RgDb#JPxK_+P=SzMCC*EC`d
z$L#kugT=olgL<fUKdy@Yx>RESngO_2de7E+$wC<qUyNQBH+olUy>ql)9<YesPqe+e
z(H!V)!^P73YipQ=-Z)3uraBfkdY5axM=?134{jDccQ?^HnV-hjJu2$g5bJLJnGxe(
zvph_Et%>?D@c{^EswLsSo82RtuG5-`wWh~)!NM?cCky)8)sGm4=yBB24BOPMgXy_7
zEl9J&z61=85#?)k3%5=E?GTr1tpDLHXi}d4-ez8C{QH7mA=Xu9q6WyxH0i&Wp(JvL
zU<=VHw0c7hM18oROA1b(k>~dmN|7;A<f=lg_jB}Lp8qPhM(=Bss?i3ZvHt1FD4HZi
zGj&n3?|Mjt&(N~B18_|JAPeG}Z0(x(#lIt=<|8xsqcmK$X|d`OFz!X`lVo3l;BrZ3
zhSoKfnebQocepxvcejbhHsxpTt&UZz7)!qGP~lej@h(?Lx&8fAA6+o`9XA$wq?<wM
z_UXZj0?EO3tPJDwRx{4u`WAT68diY+Wf@};DYXd^s3u4~>(wO?4fYo!`>7`wo4)PA
zZBor}cK~yW>>HLcgEib@Bo`UU1EA2^qPiEI(#^Y{H2z_TsZ+jhZx6LGH>@Y$(K8t3
z5LYx-!5P8(BlYwZJ?D@%-Z=e01ld@u%IYJO2yJKC$I*)5bO_aVY~eE4=s<c=UztDM
zSd9*mu8Vz&v$H?FMo*(Ry~0(u)xD?*n+9y-o`x#3ESv-VoZbHbl`|>N_nS=2*d2Zr
zV#YUSrFn&3_Qy`qYLC`xhefD8ze8<145QkILDggV&-(B%Ox|~L)(B*M!Ssztt1tNH
zGyd7aKkxI;+x+ty|GbJn5Wj=soC(#l_#@h$B{f!OuVy-j+5eWd8j2s}XrqlkvZHX1
zQOn^LSezomPC~&4=WxmUTxNzH>NSakR`o8hn#1r2Wc5D+`igU0u2%-2yn1LSi)?~-
z)h{EcFR{;LPWb7)*6STiI?AG>+^Bf}EqV!FsHsp-Si?SC2iG%y=ihbyROWB0n*yUz
zg)5XytM8^zAnW1}QGIVo%OawlXQ6<s5$X}0=3=7mX4=2T&GgfHtcb$+#hj*)L!|zS
zoZvbVfvj5&hiYH8q_1Uq0n)maO+i|SdxrI@w{GRhlUQx~aqAd~+tqjsVl8@Whv+x(
z68CFb^tZKIG$ky0i58{rUecmlCW_W~A<8y$Jqhj$J7L|2h<Oz{0~$L#6FeMwShrQ<
zM=^-D9TZ&9pzZ?-ek$FyV5M3L#C4m^T_WkM!*FA&-em2Tu6I}fO&Nk74Lt)zE7f^c
z(Xmu|g^q#C4@G$oYzf{0Lbv;F#o`hO--{0ud+NsYFpW8p!4$~4i0$|b%Cdo*VMCBz
zBzEuo5LKiD1=%;WWjXWD0x<ih3|10IFSEu!XU{<FD=)*jfy6B}@K1P4xDaH1;JK6p
ztN`i>%vk6@PWM$P6S`95)~j4p;RuC3cL!Fdv>_bS#ju5UCY5TEq*kXaA$_I+wFJWq
zXd*a?0HexT#2!<_>BtAzJ-v|^`jEQClwI`1BHZ=3y!-QRB~>MG6yc7@?e?4H<PY`^
zJa7)p4rH}*6n~e+c+v(k6jyx!f1NAd>mVN_IRd1L;V=qhJ;$QYNKrJ0<rY$8pp?tH
zG6}g$jbb*D0!0)^gn;hab>Gkyxnn+<0T@V3JzL^*;42L2R&}<_8`wdtPRWL^^D|qq
zBRh>PfVD03PCPX}E)ljq6m%M)cE1n$R>n{QrOsnTf%Io!ld128ufg~eGccK8dJppA
zYjwIyeT>noOZL+x3pz^vPMZR;53NR#K;kPnrtAoeGLT^<OF0F!Vx0-@#2?+_W>%|P
zd^8>~K*8w+(&AGYXK1k}T=Rnz4WyTM)VxU7e4?%y|F;dR=GK?s?qg6GZVvSni`Fag
zujyCy^?Pv1LRex;G)VJw47vl4r_|D0FF}&FJj)VZDS?}z^=dYRgA2n>?V$~<!<aQq
zn)(&A`xC$9gyc_ODpOd8Qx{`$)lPk#a)I>s4+)oCPRj$ax1$yC$t5@o?r`dbAj3{Q
z14@E-V5<?lmHUlA*7u2M_=$M9!@j5awDi|^VfiWuXs@5o`n1;{!($)Ruz8$#eJx#y
zmIgUY97nBY;X6B;Js<51&I4BaVa(_j#OW3kb+r8(Svq2GTqP}7j??Xq7EA!C>QIL^
z=Z!DJ<{Y8T$<*cyGUl8w=4AQVw6pOX%S?~+Q)<|_BWT}Vw%+RMzl%YuQ{p%!?P+G~
zR;Tc5Md~|%;G6V?425y5Jdpm2_C1$~6Sd`~+Vbyb+c&NQX!#p5Wo+QQS}C4vRY`1&
z==%ek1?YRHL*J)jee7E=iYM;rq^};Nx}rm0veC!+TI+jK>$|E$-}PGG0<CXcCw<w}
zcS480W^paf8%SZ6b*t~+(Y{#5$o^cw{FH3<cc%RFQ_RL+i5=TjHp}@J%T&!f<5I2U
zP#nrJm7#i>RJQ7FQmM)>x)!H2GWu}i`Y?Up008GP3~=}qy2aA!eNQr+TjLPUXZ37m
z$zMyZ7RA*`&>lQfPpUUDBF@Ngb`J|bhqXGc-^T$O;=1iDiR&PJg}Cm`Wv!z*@rx%z
zPp8U*BSmw^(0Tc7RF^{1w?4RDCRQ2zbI>orXMyWK+oF4_2Wt<cXJJPJBN$0vNOiGS
za4z$wk6I%EaM5$!xFmDW%+nCHfV&AqZXXQZ9}Yx&-o{Rww~NnlKJnM_ku`QvyiIod
z>Kb_&zQ&CUrv4o1-tFpk=%7xFhHbDSv{_qJ)dJx_`eS{=78PiVf;7dS{*0bE-*~pO
zMIlatIKMg+7I|pVX=0IVA+KU1v4AFX4bsclV(AwiRVTnCiC4IKA2F#_eUC^Ay`}B>
zV!POLc!xbrY`j1AJZ;Z0+MeMN_FQ1u^G+|=^EhrAq`4bZE1L*=k{G<04n|?+g(Y#Y
zB!wdfmds~y<R&Q2$DwysqAso`N|3iI>gQk{NsMMm+y)k>G$Gvdt=q>ESgk4zlIkPe
zdQiNN5wE8h#2domj~ek9qj;wog}czB+7ny0p{hW7&SBCs+?%fuD`Usg1^)CTJ@KbK
z)A|1DY*}KmUOxa%;2jWxj4j*=ztW<c!}@Eq{?9uW%X74Tu8YvW5<!pQ@$S=|_5Z*o
z1+vB*1^s7s=)cbB9|Zm3rz?Sx1GIBiOBXm#Se^vBV7+eTuFs^E?<0oHu$1*4PZ6G%
z>Tkv~)s9tRHAqzf3rwr}m|9oUD70?K8yL%I?c>_WSv2xKz4a<$`Zk@O%=C3k`!)nW
zmA=X9MsAMI-@`riB|5!@>5Fyx?jw<&pwsinkJjl~Ob^rP<xHQf(>s_x25H^aeRNy*
z(;nyO|B80{V;9iX{`Ap$y7n}79&1-IGy+-Usf;I%NKc|6ujzCfrhT<Wr%#~F(@2}p
z{|9SCxGu-4rjJIRk?|h;Nh51qowA!5c-Yj&D+Wa}21PuFAe=Z|*ZX(szeww!e+1HU
zVi(AIg?z5&OUP&H^uy#&(&?GxkJjlzrW1AgG|KF!(*dS`*Eb~JQsxJpZe;pvo&JF7
zk9B%C({JhY*(|$Orxhpq=XLs1rXSJilPGhyP9MRtH|caD`8u5*MSh-6&tQ6%PWPfr
zkxnO*pRChMF@dW*o$g1OES>(D^``0c^Gx^G=|`A8Os5Z}d@r58f_yifu3-8nY?pAx
zGTH6>ePX_UI$p5rhl4Y3f4BdNBzJf?&5~|4Ct-yIIK~Qn<n}L+Uf%D5i*hauy1_HC
zz8-JtC0%!JGFH_Rx4%b!o)vHwj7w|Uc;*0C{EBt8dpe$Iq~RyR+=2Ni`|^PXX3e+~
z_h4NHq4Av5^=cAsFYFU*JQPE~v^R5tNyEfu?hp^z%3w`DvnMp_CHEhk^#ZY9Gx`FF
zEAYNW$JkyDQr&{^G-EsC6Fp<KNW|hHr#feo9^G$~K~<v-e%aum26KK<nIA(4>v%0&
z>%S{yxwLxOGF;RePJNhAKV+n1(;%C^-5a?Nz>uIs$bdG2Z3Gw)=SV#p)IDZ^e6)pC
z=zWX&80M-HC|0isZEE%{k{Zuq#zV-+_dP4bFcP;?()XAU1C32NM)^F^!kgZ!sCj>r
zeT>OIUv#yqsm%P2-GcVSn#?T8{6*z5v)N=SYQP$op$<fQf<4-i*GB}O5CfJQxhAQp
zRm~7(8&o53@XJ4R4fmVOPyWuP{Gz@@7prnp@)}BRgk(K?XZZ&0wPfhYnVd5zKhXcf
zr@Ff&v>B24{tAY7WJu;^e&#))_KE>6Z@=p%CT|=$01sd{w<AKm-4Ur0nK+BhY47tY
zf<86W>;!$RI+x)V8L=^N0p3eZ;z-E3X#L9y9m+7h1j4llDwlrfnXqvb(rOZ%!k(Uq
zmgqTq0vd`K?%A;lr_wKh*z?d9#PBY>W7HADM}SoC&>exSC2>e^JV~-S*Uw;w1}@~2
z!LQwmLU^vaT`hhUKEeYeJV3<rMR6leMRur};PZT+ig@T94hR+uZBWG@(eGCbP<zlW
zYCQ;rSYiw^X!!($z50xeMm+rVsV47+P(4g~5G#)wOp`FcVaEp59TjmSxp%$ptl45a
zGF8wpMN&b#`q<#JwXXTtPNDpIvIweVy}EqBHo}S%!)op`#rg`9^(>w8^oiPnB()g1
zp;us<QRnTfuFk0YjP0PwYNAp1hA>$rR5vxOE?v~2q50&;7(Q7YX-eH{^oZ$ko$ETx
z)ODF7qjs!=ai8gWKS7!eo2cvkc3<e<d4h4IT4Qq4ow9Vza*`dcd69tx4ZR&1b*-iU
z3Zvmi^c<ftS9UyOKJwnjc>?(}dbz#N`d}RcI8Xxjo3jV-?!b|kLrA4VOZ*DG&2$tn
z+xI<6^6+b^sP8O*AkIQz-3K_Kt3?IoVRmVUHQtj^Nuq5D&CKqog|9`7_5Ds0=W!Ha
z(1zaBH}402z^2RXjz{_=asKJ>O(4Bm^x-_2BiAQ)%OgJ2ZrTaTod4itUP^CLN9)q3
z>(Zx6>2~Fj(m28~4?5aeU0}g7b?jQ!vY=iaDTy`7uuJvU<VqFC1jb-3iwClv=JI>!
z@$6E0M9CYaubZeqAJ=}2bZEIYDXYVz8zcx4AIp*kJ@6R2s$IRw#fL`?#-y2Il0N3H
z*Gda$%wnA$z;q2OxC!>IRI@alLAr=(nE5ePGP8hkI2=VXm&uP{{6G4@`11#f@oXiH
zAArmtA2!gCr$s)I@(<~WZQgs-m;PvXS)4hQ$ov_Ibw45#+hN7_p+--T>SqoS*8A2g
zP<;VZOK`1M0r*3XhPCRWwCdw}gjN40#>alQTvWe2)mGgIQr!vFp{LEhVcWZ6TD&%m
zV`;T6|Aa1oCCXzc@o^GbP|5NapggBZ#JCH_z%I3%*810E(*yF*{8S0U?dnEphVG2+
zXbHW01vuTeMXX#0>oele#CL{E-)@ErsJBf9vh=OoP1mEf99t`2rkGayIMYy@0=4R?
zW*SnbA5-7mfc4SsTecFTOr>+u_Ah8~2k`h_p8DLv$g+)ID517pZIuOAI<}v<S64Jr
zS1Q4Ds!qGmV0D5{XE5E*81q+cxY{mD#ddY5*d>p%)#0c{JtSjqy?WUQOhW<n!#l8O
z(V8tV+vOb$+n7=z*r4VZ`5T;O3}4fNOzaciq={_5SpAFIiF=^XI|xKLD2X=t*KpnW
zMJ>V=oD6`u!nLXjT!YU*ks1FqKzGQ|*t%l6I(?XQ$f@Xfc8CYnn?US=&I{cMBMaH<
z!`H0T=42UjZiS={(JQDlkUr@k2~iH0^Taz_Fw33!kVI)xA)^e_Z2EyD@P5e8Xs-m>
zc6BFw$GS(d>88_PSgkw#lyEJHs0H_QoUn6iq3G`3-T8hOy1QXj4(Ls}wS24w-L&A;
zQr>BAquOt!i(}V3h>8&(`jr?bMk-`@B-VK7jP%PO!y@OgGmIrC(GvdxRGC|^<7&7>
z^>%d&r5JJS3P<5l$fSym;_2<GT=#1zq&r~z+bF{h*rXbcl@3^gcN9_e3iySy-8LCm
z9kbn);#?h|_q{~XH4>n=>9hpsbx5<$h2#(^dt`>pIw1jr`KA=svW9Z>iw7d1_d!fy
z<eY5^yrwG!EkQnvbYM*?MNZb~1g4MCX(@V$DS88n>ZW<$3O8*-e`(qmr%Ka45wEtZ
z?ySWgkGqVI#vsE??l;0eK`$!Pp_NRXf%L26!=d#DmG~H1-`+2wwdNw!C86~!2{`sn
zj6V}v*-%H%@QJk3=nGeAFMR-x!zQ2DI3(NTt(3f0m1^asn7q40SJqoRsT=&4PTuVX
zk>I;~9gj?XleS7{KP%mk*gRA`^4bHsvwx7Wv_5z_igfbK773H>Dpl82#JV;eBXzMS
z*ps*7XRL$e7?Y0ei$SpWf0KCE9b9QRB^A+YEAA7oU3;P9wFM;LwNeq;u6n`cblLO3
z^}1*8cthIZ#^Mo@1}Dbpc638KxJ(R$Y{y>7J0A1OQ0bldDN|&_B=;Hx>hqN`uG-Zp
zTQFQ*-d?;x<k_EE-o{qoJW(}4fGM|H!4z6^GR@-t=P_2)05*h|N7jc{%A&PiT?`+G
z9y7Nht!g{0$E}DP>d^??h`90mV3%`yawrPvo0Av7h2q%GCv@%%bMsPw{24CwSFo)9
zDGX=afvs0RH-o?qG~29y5}4dY&w?bEtWr~A0ZQa>KbL%3yEhx2I1vs;ba%Yg7<vsQ
zhL@zoRUfCWlHrZ#0II)~Z&g`l0!ai8-6c(5C3j-AHMqgToz5mz(@LM<I3YFk!eluh
zT=eaLPWOIEX-&K{f>}=vh9B`d%O*~pa-y-nyFDH+?c_?QwyKMa0G4%=a{_a4@0Vns
zR_wzDFM4&r1s9pa#yYeDL-TZfAd!dID2C;@nY;dP5@G%E1sM1xPj4*7gH$o_p-``?
zhhL{GpM<=%f*sweJ{+Vcu`CE-^oBl1=is(YJ%RktHXVq)Stke71~v6)j)ugmXni2P
z2I|=f4REI{3VirHn<XE>j&95zyhX629}9p-zM6up;CzfEV@?vx3BATU?bD4pE1*f`
zY^H=hWcUycVA1c)l+qu0wEHA@ORc1LU{$k>TRi_U-I}1je_l6lnlM?Xa!&sJD4LS>
zBhC7OX}$n_g<GvNvct6O;aK6+yU5pbVINi)NM8UA@BwR+`7;oEc!N0nxhd4-?BurH
zi^4b2oIq9#6)k}xx&|g6&j3VQ-$S<6y>gT2zI`{1g@0dFw}}n0uRsmlJO#R?Klo;L
z`a<eXm!`^n##ZBsg`hB4HiY)4qvO=B=b#Q_1}|i7$3~_*`yAC@AXdeeXw|>ti&Y(}
zkE80X@FwkB2)&_~wXTOc>v};Vp;g6eD?(o(@DA1rAMd2_qkEvxXB4JU;frQgdvznt
zk;W!UY$Og!lVCaldRYBL-Kk9Orhgb;qNr8<cm#ayU!9UHN4^{KGk2hUf1ynvc>?Cf
z0}8$qp?3`XnVcpLLF6>^Dtpvcx(;O;grS!{6KCRW@6{<SBq7d&Gl*9gxdZc4W~e)#
zrJ0;FZbB*~^XM{&sD&nDimEZG0#(iwCbDn17D1=Bc)hmxGE=))jF%hkRUUe1S-5iU
zY{K=!xa^1mvFc<o_cKSe)_a(ct?DvVs(yQwz4@R#8LpQQ!2P_Ld|Hr~=f4s!>~g33
z1-#4^c`L4})QB!HqWxttT_4n2f9)Jh1Uj^qvwzS!ry;TGHqrH6XS=SZ7`pLe>cr|J
zUdw+5bAi0V;V{F<bi4s{CyX>B?pyYIAaTD_Bv4}R=1|0Vf;v4xRd$H3)uP)@7SX@o
zrA6EI7~qQXzy@q}j>iHX`rhq#<I5GM!+qDAZ^<OMH)Y46UtJrs6I`mcugjIQ1|cPZ
z*TQS3u6YpQoV)nD_{E?9PA|4A@6%|-2LPRYuz+&DZ$)$kb8++`k=n_9=Zdzks&5HB
zmb03b>Z(H@bC&(-Fy{$y?fS55-aTAg^ZiNE-W_-9_Qs>V+BK84DCd@kwCH**x*DP!
zV_(UT#?BWmrGFOFmk9G2>d{8DWPjMIHTCSM^g^v^p4L=lD!oH%3UYHndvjqgrosCU
zz*KNG(>xw&R}-O@-S>uw3zcoCm7rh~C)wXoTc}yreA7B<F5B=0x&x8WexfvY_Z_+o
z$y!yg7B%Z47waO_^pr00rY^DpMOgcHdaSU;H?v_*5I+AD8r}0ZR@mW_N=VT3Wz5`-
zT_b@XfSS5@811$-U25{bL`^szG;e%OCJXnv)mbK$t#X(`9Mr>nKEX=Dpd2e9-Krj>
zolfB-2!__er`xgotCNy2`6RBzpl!wg3*Nz(0I&)?kNl_Tb9re22Cg|2YN1}HKdyP^
zdtfpXeod2+$;mE1^B2_ozF`=hc=alNaS?Aq)_^rHhh@FHKeRtZt%0oHY03SP<}MBX
zp8X`8bdqeBH-xL@WAo}&!9z41+`|oYr&=$vYNdrTVZy>SY9w+(D=5vtVqO!kV*PQZ
z6s>2Do{0GMrCw3=#i}0}8jeRdKA~MNzUkzcH$@EN!0r1?-3zhcd9v%z8qC%|jaSw?
zH{dSH!$=v_9Sw-DTZ>}BBk_l0;vClJRGvowaxIs{K-SGvJcWt_S<~p&d{fDv+kJ|u
z?9c5^?Ai=?WG^BmT=m<JM{D;7B4*nCFvNmIGF{2bejC)SWX21V_3JL|q#jPBC-~mM
z<)V|D^Gc*RL}rjdYjI|WhJL1|7~BA?&N84DeWy-$0CUm|C?rTRAe-P&0la1DW$0wm
zE(2TyKR%`_Z9)91Zv^lW)Tf4SBK?j54Fu~9s3myb6qunNGjt*8dkE0VB(;<&blL$}
zN65sfg(fdS)gTq@$rul0efk5Ob6p?l&1R;rL>f-vj8ni8@Jl_LKGGB)pfXwfO^Fl{
z8wecwyPnVjYoJx{Key52fyBMXQAzqgZq*ao5i(({4^?aVi#p_=)bej=`B#nnw-_Ld
z$XD?l5!!+&*ri?oV8=a$Yw!SR2);bZoVz6lE5v8&W@ff>Fz6Ly!pp`J%&bNx)wQtD
z3@Nlj73#uj3QI0#NpW1BrdjNC=G+<1IR!BE7R~D~GCS0fa>e(5C|CtSX2zLJm&x4y
z2r^Ts#hSdIr6*vKG~**kgw1;mfJ@+7xk}qsP{YB{puKqLYU+|*KYzIdUavb=ynf|U
z?e&LbxG@UmYbDA{4X1N}V5*g7P6fkMhMFQWJ5&L#q4!`U1L<Jtsn38#dWexuP{$(`
zT*IX(kTvH!M9^sm!2}2;Foq5=a#K`{NexiDm!pIqCA9VDy(HFi-F)<5v3^s3vA*dR
zy>2Rub>!-bUqWG~lGW2lWiS3t9~H=E?Org8KhXrALaQ5$aB9BqOLesY32H7<!D)ya
zZNQdQVfPKx28`AQoB;#a_UUF$QjC^iD2!fZIGjQ~*GH_vJK3Co>BwG?Adon786YwI
z<HIO>HadV2@(lpHc$-}DRueNjj*3pz2GT=I=-fc!gDK*ndv4Yq+Sp`y=ynv=9=Z{!
z&K_C-rjv(e8e#E}$AAPi87cXF5p1GqSRxuV*7t3&1~F%-7)^z)(@wnQ#jq2<>Mb^Q
z(>Ct8Njvcv*ocS-K8udgMG8BLJgtko{TFH0CR3#K6<uTm<~Ft{L9KbnY1^|%aSnJ4
z*Wl@UASeQNQ2-9#%<jL@$XrXAzL3%Ns+D0=Gj+Y^=z7PSdgtnTL!-^qaVY%{^>HeT
z>XFJ&gYAlrHFSbHf>k~BD=UzF>Zfd@6paZN-Tk1`i0_dKPN(sKtO?&@?BM^TD*6Yg
z_n9>fip*rZp7<F(%;I-K^h11mh?-@XJ;+@Cz6fH3Ub&UHn@llc#^kUWS0G2X;4+g+
zR?{hca(F;)eu3u8z3*WO(v?Gxp;yySsn_9l?#qrV@9q%&o~8#9duq`hM)X98nt*v1
zZf6W#7#?^YU7FjmMqT=?qotyaH|m)A-b{*knvS=R9?+I2sTY{SusH?F?K!l99UCx1
z?`8@C$k3}ZK!#ooKrj={<<Ps-&bb(X?mLGP&+gU|dA7u9Mq&shZh}O(zGKK-7!I;U
zE5wOx+Xw8aK;jR{(zcy9=(Zgs6Kcoq{TVt#B4x|{mgR2%a0IT$HCWBS5}D_O#`|}q
zAO1yKdasfFt6baFjm$g`nL6&<o)4RpqfNS4n{=)*>8jNf=rF0DV-hF35l|NPXS%8B
zB-X$ad0I6<9Yx6RoogfG3BQ7)5#F<dh}okL2yZTaybpO_pgksHza&0MB3Nde`{6%C
zOXy2&`;ZRX>w1Yh@9QV-yfdKPxn8E-tOHohs-EG~tP7!r?(4y(1u%r!A#+g|L4uma
z6r$j3l-3o!@f-y8DdG{jqD)=UAXLPFIUk~2jeH-5PC>hVjKvl>4;6AD6`h9}oi{-c
z1+=VspACSMvh|rnAG+2TVu=j3<8RW(?nQgMd3)k-jCV4=qZc||ZF^RXar<5E1sLZW
z@do3woTL01>RBjISFX}Z6VjT3!{_l$mRCb@_@hdhA=db{Zq*&us2l#Quh{4-roNLc
zeW4oBr}}~mJu9uiqap4sGoVtwY@<DPyHN_q?xY_AiTfTUUE{i5cg+B5HI8^+y$%QK
z8>K=lr}}1Y9}X5j#wsUz+?BNPDz{GGO24<NQPi=hJANPHu9O)l7aVe@_8ImVHPU4`
ze`{d1cn6bn|1Ada7d+H81~edtu{_6M*)^0IAluvv0fLuFK(9_I3>#Rg&0yJK6qjgE
zH3g-LzW{_*YL8s|3>z#H=$8G(BR?G>9{K({J%Jv==@@I_XjT-6oeLUnOBhM(Fkj2l
z_F*8^cbw5MA`!N&s-BKU``CW<?7iBIIQ0lp!QP@N>!&Xf{x9KNh;q8M8`KgC^r8Sl
z)Q3)7Eniqt*?aLA6yB!4_?qGX-K_Jd88Vgh+=Y<I_m`x&^D|3QlH==e3xn6h<Qa;5
zi_5LX(EEto_{CpH-rkt_#dyP)Em223O^X*xb+SQ4CF*t*P|wNj#Igc*G|re<m%Hwh
z_{DhL6W;a07JTE$UmT|{ZKU0;Iqe@%A^j1=Tjyp6A^P>kw_-nPO1%DXade$ehu#w$
zX1Gs<Y3hM}Apu_|vvDp~h}fBV4}8Nf_d+}IiR?O)uf{X;1?<uIGAEqmitouNWmvFP
zmAp!nj+P<Ns_sE`Is_Jr*%AUDN_Qmg>MNFomgo>Tn3hR@gbu_6rIYFjI?ON6A-+}3
zce8{!E}$r0Ui(_DGHkflg1InX*Lq+_tsY(Ld|hj`sr7CQG%fn&Q><SM9HK?f)}mvK
zXcfmK-r7!J`*A%8S8b@;7gh#iI`A*3HmEqy8}H~*ohris_dl>WxIixhpSGYU`tCyq
zI-S6nRA1et+uG5p3f2puCWhe#$;J=)5Uezyp5O|+Sj}o{*rE6hgvH}fPCZWxM<K=E
z^(f#0^8WlXcl_eBAx2KVMQ^w>g~KyBH@+W(k+w<AL2*jO>7(cAgo|FC5&VUXKp2jG
zvb}v;d~1{2Uy$tfS0>>sHkt9^_SYoD_s&jGu@F!#2=v^vuY%2WXd7n7W;0LKm^sZw
zp*tmXHmGM!<^^V*zyR2w{s55i!b)=_C-zZ4CyVs;-EhG=@EB}k#0)@9>TSxGK~wNT
z)G2dzt9lV6Ixau(fJD9WJ)xJx-cr(pml<;IO&UvM@V2_l0b3r|t*+FH)C|_ro%Z?<
z4~~XQ)FB9_;DZQ5bpTUOF*RWv{IO_nkN7(OUR^!`6{|PU-eBJah=Mc-<SqKGM>Sql
z#X}QRqMl^t3Lo5s9!=)(GH=R%&1eOeZ8)AizH2xRM+98_;#Js9sF!F!BT~5K3yxsT
zfvoA<P#xYgfZwt%VET4R>yr(=vZ>-bIt{kq4LV*YQT!5$%UG4)7-Up7u(yR$15L?}
z(0y)?w$?>!F@O_zm5Jg=yB)|W2<LRSTGM%Q2_j6w{y>@3aG7_Q1K%CT7=lq;&P;Qb
z-rl)6uh0|x*%W!$cAF{qJw_;ZN4JTBk(kGK$IU$$)98otMp&!6xW__wx90X1)^he^
zR1v!s^8@0q7bOsXC%|s?GeRl&)G{6BLB<v2Z-R1l1Pft?wstUoyH=O{0Y-#gReK)&
zlf=D7g6#|4r?&iAVvUh_f)cfA#h)dH8wo!o<PAD?6NLWhpe=xa{0Oa@_Gf*eYqZtF
zsgH+eD#sE^k|$5<WQ%h4Yo=UxmV2KAW4}KOU1N;hh7l5c5<(pOf72_U$`gNXP&XNz
zY4Fts4>b5PgAX&f$l(19KHK15<+?%T7|h@OWqoM|e{As42EWEDW|##14d?SY8#q5#
zHOtH;4??EX4@)e5gpuX^u*3=p?!@Whi}WP676FogLS~M79zJ0pUKFY4v`%{NSx!?D
z`)NJRyg<)pXg7Lh89j;6!}qWQm?afLkh4G@)Au4x*#LL{6}Rbos~u+SHF8j!8D};F
z7c)*XINk6f!z5t2&`&bQ8zvQu^F(C0;W%@;<tyO>$@t_UXuTBW)670btdU|E)LiBC
z6d~gQ6&H}<0|`if!;k^jW(?#v>fSRPx2=@puh+dS99KO2&{-k(QB&0A53~AK72`DW
zPc<%KDNG+rph;bDEB3Juv$8*%=7As|!JbN)MfEx7=A6Ut8}N$;_?|&(r<Y6yq&4OF
zzUKSW3A}6SgUJEkDWxIvr0J)nXdm{J%46qWjlSHJn+y~14&SVV_;Z`M56%xPNX`#b
zCqYGg?_6lwgZH!5!-%@jC{Dka(X^UZ5hqlB1cn*<mpAb@EoGIzD4$$g)z!FCBvV?k
zL;V0PZa;RU_M0rH(VRuErplKXaxTvC;2C$;y<4ydlyX1f+kn%vqZvJJl}3F?Wvk<m
z3jeN0UjU4j1JvhKh5ESO>OEJ*Lu9b$+Mt>^$ODO=VQIi*`q7p8-trGwX*W<8cBA<I
z3;K>t*m#Q$)R%D$-3N<$(W3YD5_O&nalHv?NV3rF6nYma=dJMF4~DDF)74JX)p|^|
z*P3dxq4`<-f{2=@HE(K1dRB+#GmIIh;u=iis6r+D2`yH;3yq_#eOdj-y1`dEHNUFf
zk?maKxAD^8uNUZDa4*&z$U2r4^*}|s*qKhT4QiP#_Pj3kq!epaAIXsF@Y5Vq_dPdj
zKi!6FaIUm9>x++|d%4~ST=NIgcOh+DRSvn(+ib;au%hjE<X)*Imwu0Q71P-Io&-&%
zm8VfNACp0zzbm4~i8gr{+(xq{G!B834vhnlLQ&O&<-SH^%oh3|H=*WlbaSUXz-nYG
z{)jj}apQsFrB~)_FYS;>+8{mer;#6HgF&rNLW{2P0i=R;Iz%~H<BPYarFg$okHa&e
zPvsQ?u=qMgKEIgT`Q?F;(55YU`~I*c{j?>gX-m?LB^S|>K-LW(!iY)S<>-gy$I=eG
zM{*RcXqSKyj~qzc+JWCjORb+i@N`tyC~i-DtCuu<;}yE$-^=VT;kCYAckN5KhWzX@
z=ZAFW(S30H0Cg|&g5R=p!~>Wg=!97HFgpfRfg3+?Scqvhe({qqO5F%P_<%GtYvc!L
z($&~EiYn+=XG0rHC8;y1cPaF0FD<_hQo6r>r4Is$hiJ3ojoGJ)+2Vmu(Zt}#I$kOn
zFGtDNRPvgbH(v613iSDny1s0E)3HmUqE(II%!cM=s3r*TYcg49eg#Dz%Hd<yOTQug
znxwH-(C*tI#^AV#`f%M33SPl2o=dg<4XXT!4H)+L66~+MaBCL3i7ENnsD0HHSYlav
zqAC3bFjvy|d9qMs>PcojX_SC};?!|Q_FgW}fvg&uG?b!}yPwIuTIXIzMM;jqn5&h#
zK^xkFD>ngCwBTB*Y5fIiV9u*1?=;Ed;{A*%b-b4TlG1A-P2+Dfc?aseLs_N#<YK@)
zo`?BWqOnz7Vr0MII*EL4<JDx601X6g1LU-5xB*;t)ybypLoACkf&`H9J;!o)L^Dp2
z_-<9#B0IicEi&<?yg=46+`*~tTnqds^`YwniPejENxzc!b||=l5f;d*q~KPWRT3v^
ziHnTHQY|r_5-Ta;YrP11PSR2tpo5n|gguugr%SQN^OCvSn}`lS2lFUzcK2&<F?Ovt
zSIBo0`Sd+JLK*mn+t=n^`~4aCrO)o}ZX4b2{^9Kd1-V8+Tzkv3_<o~YE~h;Ie-*V^
z8&K9&J$SNvQC19Q4z%fOJeBij-LMe<uZqMr3=>t1<zr*)T@dVc(fVm8$M;)I_qf(i
z>qzteXF+|z>5w({E!q>~J$UZEb?@Puy1rA>nw)xf#V72O*0c-1e~Z-UI3&)DLmr$O
zd)^#6bzhNnA$L4-6ZT!N?OwE}oA=;Fd%AmjK;=Ol`n2+C@L%kHc6r=Dyf!U<z}ofo
zy1d(et=@oL%jod#>-I?kRqOWnuiea6)jL@BOB4Bj^vL%=)r_os{fmNQGr#uYmjCyB
zUr79Eeu6Gpg&NSg`1w72Ik|dgzVC@GD8v8#hxwYNll4yMOVp9=!ftG$+kYm$^NFuC
zV*-5lJ9oDY?v-#LKmFX9Ke^*aeDBWOFn0ofnK^LU6VQjj!CL$iF@LOeul*v%iz6xS
z-BmA{gx0!!XT_l=4EsxW^IOurFTgnESD(kCoY*Vhe^%S>!Y!8FfiCxpy5{zM!@EVc
zen7teDtO?yeBbW;fi3dmvYDIX7oWzxsqd#e-yit{zd?Y;FFpWF9=~(X&sDIOF&ux*
zhx8ox9h11Gc`+S)c`sXl6t}+M){hDFfJ5;fbbjE{1oU_eVxq@jBt|egMh%Y3hs%e%
zeOvQ=EgdE!pW%^>=Hh4c7Og|c-ecPEXT)wet-8hSQ!qF`Fta;uhkp0=$s346IoN?+
z(4Mi~epmVT;IT#BR~-L4)G1;UOyKV`ub-9|U;ZI}q<LMQZ*)RVeD8hq8`J!@tZX!O
zzt^=_AM4(PGVGU}HJnk>J_(+N)=R!-<bQqQ&V0umKN{azeJgM6*FA#Y=|$#^*D%)&
zWj|<n*`ecU0>UEm5AQU$|6+U>_~bm_Pj3GidD#8pcTcwE4gB6caCg4%2kD5lzxHrv
zuAMuUxrm{4?ty#UzK`5%{{a0%{I!q5qH%#9r@Ha=;e+yhyU=#^4HlNM-G`)%^|g(q
z%Ml(eW(RG?S#H{Q?z-2!$Am+1U(^wQ?MqO`O=Ew!jlb%Ot+DuWC$;y(_|5n4<Mxk3
zZ)}v_$oGwCbNj}iFMh24O0Scz-`(CmJ}@fXHP&|`3_y#-gkTL^hVhGG-H#@Ygo)B3
zsm6a%T%LaxVoh4tZKrO~*7(I);^=HFY=hkXF{pPP>O~~@Dp9W+^=_^HO6yO8r26i5
z%&}I)^A`oW7=LEe)qPhpo}&&k{18~}47j@Ysu8K3M_9Zw!b0du_(8@O{h`NYHOH%O
zZD_N)6c$(p<eZCGyK=326|BQ2-j#EXdu?!to_2h1T>WJ`Pr<ML*4@K}x%JA#l=AMp
z_BsMrx6k<%ndjssHtT+FaY_aX;ClnORc*kK#4#a{=lIc24!{@iTnhfrpb+j!02a$H
zuM;-{#~+f<bAA1WGtF#@KV%Zbk8X}1czsGO)J}`9=+*aqe6@DqQaR?Lg$rkOXLZe{
zy7)tuic%Kg?KDMOkVnyTwP-Es;)f#H$l|q)R}|%x%OZF@O|7YD6+g6!3qM8i!n~{c
z++WuI0Z)0y^P$9Xc&rsz^cJ?LC{hbC+JX`dxVTs14?fwVLuO~gB!snw#$hn(^?>SF
zw^Iy4-OLjh{DcBc2)x9K&=m~;rarV2a!s_7HH`A#CAqoKw&YT33oI4?@n;w)fWd~D
zaSGSJMH{;LMm>6jd#y^Y##q()?nS>R&%uJMzk#DRVNdFRPB%w$kBe_ndor7fk1D=|
z=j@B+{UkoIX+eg25q`vh0-Id4u==2v#ZZJdA5_cy<EX_P32p2Jim+KQn;*456hluf
z(m0<V!f!mFnq|@|n87Qums8wSb8xtt15u5h=K{~Z%{vHP4SUd3<8-jPzl`7cn~50>
z+8d$F?O&SWhCP0lZxh^7FBIY&6dxlX3SIFx>^%}4{p(9qrt9hUN#@53_H1&+QoQcH
z__`l4Q8U0(A#d#3#8Hr~F5?~-EzL#_6|CJG1LVXpo?|wEj9)xeUZvE>?rSK=(gjYu
zVE<8u<7aF;zRLGMAO^D&TPTNy(AxNc514}?jJ^29mrx%>l!$=J_dOs#wLy~dw22Mp
zhbv98Bz&Q~%x`D+=cc!X8JIE~x%WmT6y^_mupu-qc~s!E!`;5erPdtZwoyJju*&DT
z*_^(NsqB2;A8NK;n1%8Y($tXFl=fb3-Ouqic=-;3|8X&Nly68%+RtfC`B0UR50ZwC
z3KX}ey@x(U9OwCVyM4j@!1x}zA9DQ(qx^^ErnQfae`;%<@Adp{TgKuWoxSltOIzC`
zZ;|SepZWLdtvS9?&!cz7b#uo*-kj`SyE8d2^B?hxci_Q(zV98k@9ogT&b}Az<mh8$
z;=+DFvH=%~tB$c34j(wG7Gi0ixMA}YMA71u2Oy43%MzSsNbksO;M>D}8Fo(?hj%#R
zaM9l6_-mG7@-bs@n;QAEcD95jf`fA#EJ%hbei*IviHTO$<a7<AwGA&%#@|>Cg_~k@
zXg0;yJ%;z+C3J(=BSZU54<STu^^xrAaMY^xKk51<qWZCFCsO@5E$E11-$&iv^ChhP
zzTYbPsP1R)2zQ{Wn|t_k5+?E2td;lJwPsarDRukxZ0ru4ji>laB^EaI;InhIggXsq
zQmJcl$LFf>SY@v;OcQW*xqoS1)FS_rh-5Z@i4?|WO%It-S``B50r4Mdr2mkaG|KlS
zF4-u<W{n7(cJ!z~kAzV?3iuly(Z}C73A6pC9x1G3O)CC`<6^1ITA0T;V|Du|^N;w&
zzo0};{9T)J<5#qw8JK?tMhXAF68;M@H2gO=p!6vJ`3X4#xBK?w`hNFq%kB1l&f4$#
z<z(*7i68s^sKA(Rx!C+%pN(Z@ROY()8*fD0ax!1f@x7T7C}_`(ANNI0=BuOP$G42i
z{38DPU(k6ReljF5>T01s?dR+zkEb*sl@H74M7Qrk3_?F9xKJs^OK#e0qcY!{pEN3S
z>w<%Q?_;wQH)`Pf?&44U7vAm4>-I6~U2y3CqV8S5qpHru?@TTd6x~5l<0)#aqcY+p
zD7K8CW?%w)V2@C*v<0O`5$lag5>P>cGXvS(Zb)0LTI;E&$F}yUpPo}iM1h1$0(gUX
z0i^<3mAwg<h)M!#^8Mbm_guoIr|10pf4=AA(ag-+Yp=_DU+;R?yTZ$7@=WKY^3V$Z
znI7026Ep7%0<w(In|h)vpv{}hgcI8XdediRYDgm)Qh5KY--OrB{B^`!9|^6ASFIUk
z^_k!Hb02OU8v*xJbGdBT0?WKWBOUG+mZCr?w5c;+$V$jus!+RJOUnHsLJR{Uua;5h
zi9?^!6q^anN`3i(jI0pBNap-YDsS@4m#w^|g<i<W!vR`y^a1j4K(0JgkYgB+$Qbx1
zgvJ=8gErO&wLRqF6MH-sk;;M)8M{zk=^^A{naIOZPacjJd03VEvb-enP+G{y!@m+7
zbtrkrI_VjO;{R*%aI6Z;>LCxK$eSkx4p8=xMP&*i2MMK06ku{E@P*N&@<DnsEn<A3
z1k!MBHP-ygp%rGu=fF2d)EuBNCj=*H$qBHEye&kK)t1@y8~QR_rS#>_!|O{=bLm5s
zzPv|T{HN&4I+m$vq1;1X+JzZ)Y4#5asVlOP0i;zX!Cg*8?)%g#6ILjVT77~tKGB_(
zsWsYsw>XDRL`90;^i`&>E-U`I`f@fs9;h$DfhZ4|NQHYm%HGp2f<IAv@{g}|d{8S_
zm%59wi>REWSg2o5?Pb|srY-d3nf6d)l*!cbEYyrdC6^@Tkf_NLRA@#0IYY1=7CcWF
zv>Z}P{YeFzW6ujOvevsp)QoVo=;hV;3x45^%PKcFv5+g&?ZFFmyZ<zE{5N_Np+Fp*
z{3Nxh`uk}mCcIsHigY*Ld48AR({I~vR@F0KQ2m+xe<6?C1q{Lob;vd8-k~7Vy)O?B
z+kdC@&s9<Kt|-#97DS<T(oSuESuLLFk3@Cl_mCcml&O)34h=iicjD~l$mAMX>rX9~
zakK-5`RQ?#q~Xx-m%!o51K@Ch!OZcPL;~@lqe^Q}G|Xn%O8etZSv-#|iCNRtL%|6i
zj*1eq|9m-XUJ?*M2!*=$f?d%+;SJgY&+y%RL$`=b0IZ=^sh!$<aq&d$+fL?EjBouV
z2>XIglpgF6IB&g`hrA<Lw67{s7S(FVL9beERDDosZjB^%1Pr^MjS|8W(dThK@?!Q~
z?Q#2On0<R=cI?ZD_IR@qUeCw!%HsD(EsKPUB)%!o=8oZ8CCmOmmmb)MmW(uQ&yRI{
z5NrClQ285&Yj^fPX1Lb3fA3hrEs2NM*6fIyO^J`b39SyTjf7WoYQJi=HF$wuwHA$N
z4qjmE-FQ;Z)~nX&Rjr0yXv=V{J`13<hvci-=ix*r*GLSvqP@N`qu>9=u7qU?ZPg#)
z%9oT(!ddup7GR#S;#(+bcxHg-n%;BYMoIHeXthxNWCL}i;B`((#B3b2#-KH^7aF2w
zbEVbSToXw&24Z&qzr-+)tqYC7dL7+ver{ffci^%}*r|Chunw9zIcE1sSb?lOHJjy9
zuEegujIYc<#J(-qjU|=ZdEdEdKGUlRdo7&PcAU@unBIw<EaW82-zuibo%X~)#QbY4
z{7vnxF&vz}y%Jl$GZy$Z9^MhxM(h}!_CuchKn}}geUW>`7ddAE&nN>BGF2fJAuD4j
z(SqV{>u{D?-rGWmJ;5nDUqnQrFc`1~2kl`e`Q~5s_hz4F?y-Mb?jDN)KDoiOmknGe
z-h3kA?X#z)k>Jk9$L5!to0bZ8qxKcuk<i;wP2U^|x6NK>RJ~!>bVoxUX6Bi2^V8B<
zui6_6xoyY7ANbz@Y6KF(+NyrE(tLZAHS=-UX6C}e>W`<}+QNQ88P!ZIXrarf`Kju!
z(w-3P4!v7xZjqifeHXoI4@j_5yb9~FI@lEnwdM3(kkfZO^nTlSd^r$duQ)pZEosm~
z&p~{s&65ji-ECho=Zt?IOxkyKN9{4p`kloJ0-FADW%wiQfk8mszOoBDvNH5hnjp!)
z#}FR$+y?MR=(V;JWj<JqI+JGzdiZTE`4zZ{m|s>}#;*!TS;61aVD(=s!>?DK)E!A|
z%a0^>2i%7lNJCmpq;&*>sLY<)?Y1h1Lj^L_b4|EA*qH;)2F~G0QBW=`%PAt=N}>=<
zxn{r5;03Y5CR{lqQk4?1%If&+cuzNn1*u+c*tZnMO*d{5k9u2hM$`^o8e=;yUrf*v
z``&K7s>85@|M@aA;O!eR><E{gn&!`liO_iSzKii_Gt^R;F7RgD?*EcuzNyK+iFIDY
zDi!Cb_FS7DaAM{TqwjXSooWpm!^_FY`Ui*GgHIIBWpNuY3;&W?&FW!;1FMfow^I$~
zA|p3&a?HSLE0-zB<iv2VTApg1eQeuz*v}Z(jjozMSoDp#&Kf+2CEWI?JtJU*S-?+I
zPN51hSpRDq%w!j}{ZO`Iy`{T=OMoQi$W}hrKdDwz5`7|9HCEIk#a<0Q!IKoWEgxEH
z2l8#bSEePWD+T$CrzpO=TlkF?e1zpjQf>)~Xur!YsobY1ncN`OvCxZU1k1yHf|~sq
z&61VUTpLyDqB=MgRQbqDqf>A_W27BCK^Wl?UWmaM`GQE<D=3at;iXmx1#iM1GSm$I
zaEO1COYdvx_P#K3RM{Xs5y-gCvret#GORTEb{c*62>SHI?m|J|mJ#;g{50w!X5kAx
za93ROJEigHUr2L?fn_1%HL!@L9ukMAxM#C!%#JUO&uSK@S$x_RYK>f~hhYyNr($7l
z{!|1cbeP6u8iT%l3BJF+R#sBJhsj6m&2vF4DJ8(_lZ;MF$@*_S1zPfTzR99R>HgVp
zs4riH?<&%Krz@*M_^wQ|H_?K0FESk8k-{QP<zUfcJmP+CDOB8+Mwenc;WfdTSOf}Z
z!iPxz8^v$*WUx`jr{s&`yZ;7n2eVxUZ@M)s2<}SKxHAi1IskRQ6{RBm$?PTx9%W2m
ztt_n@Gn`l2cDfIjG`?Q&@D;WC&%ujZ?W8%d)WeoqGM0a$IPjKhJPuSQ?!g>b28*XT
zaA{H@YHA9(rKMz@4VG9}&sB_vzXX^IwxlV6mgrCSWtJT%wIqWFcD@;|S7FzSM`Ii&
zcY!?~5wfWgPgDIE**}1U#??hjyD|HGCro&J=`?aPkbSAe>HJKn%zFT6Ds*!^yK<h_
zHN@^f(Zg3mW6VT3d7(As<jr2@+L=)E{+VA(%xOiDYNDCTTwA?bWBgho>7<rglt8x<
z4)>f_Wq@Br&7LZC0tKqbWv&lM6~-pp8<{vT?hh=c%AA$5OX6*``a5(esTQ|YsTL1j
zW}{llxxYkJ3f<{Q9N`64HCnPjT++-_#wLb%r*8Lo$+I7<Tsu7QcE${Es`*rw18eBQ
zutx@rp`QD-_B4?`$mM3|Up|&b{a*aWrK&Gw4JIf9F#Erxr54bP-ycgB(5qT;9=<|+
z`JTb9RxbDM@Sz|hN0`bAZqQyOcZbzS%yzRYVh@{P4yzXhgzrxeubuv>+ubH_Nmz}^
z&h(AYJzK}Z6rIu&Izw~?{xw&sRTIE+{u~L<prUJ2ru1KCCIYWN|F7Y7CvP4GUfZ`G
z240G3bAWXbZ8QMbCo^!mlhXq3dVXf*t>FJEg=-K0qisX`X0%<X#hO0JH>zGULLXsf
zW$O>OuB!iri){<dak8sgv)ldl3viOLr~U!>sVwRWe!FL<;WrEAi6=$3J%Vq^hok{H
zJX>>gdKbcJ-$JDve+pmMfnfQk=zzJ_@qM7T^W)4Jm$Sojz|Kx-+OEoMz5I&Cv9HoQ
zH`0%+L}eU&P4Dj1oGL@ys>sTxHwIbkp1wVU|HJO}$WUvvOo!j4L-upMEgZisdOE~j
zkGo1ym&}ccdTVvXkGo-qwCeev@#Bj*{HR<6iXV~E&Cbs^d-RnS&uVQV{3y1g2sc2Y
znDJiPXb{CNz#s1%J629sdCL-GC``kAwYd{SFZedB+Uq5Mp6Vd&ZX{fR?H&QB#A%!?
z^Yf&-f9&<g_sej++Q>E04rv^T=%aZpsrDzrWNMdR3H6IEl@t~UPW;h_(unW*pdUGP
zCxDjVp=^I5zMVFB+V3ZgD*BOaH>dpa%$A!s9)pS^S}>+!>_@5tU$2QUMvTcMWZQDT
zVfXo6mOm`|{ybuC*PC{hu^C^8p|v`uJ=Z8J*Z`XZZ<wQT<nS!8Di&T}vyRC0n#<f;
z8uR3y2kX!ND)aGhk?u?vr6zCsn=Mf@IM0hfiLf@er>Q*+!S(c4B&DSJMcaDlJ(pig
z4=wMSe0ev(xooD#uchv@Qs!w;b17aC+5c+fQ{;`HD2mV(LIDuMqEW^wLOc@qJQC=P
z;Esue8?^=Vc|&#%7KoE2+!ZnRN9>C3sCM~#(eS#NcL_ClwBYTZ4Qj=HUK4Jgd0aHS
zde$*!Q|NQN6cMY>1A1UhxO3(S(QxCez7capB=mK>YST#B8ZZJM=;8I+yp!lb53SXS
zkJ9Fyzz=Z)G<}Twf8DI7MQ5Y}6z*j?&2|XhKiA=pf{(w+2+^rcMt{S}7gU~zO79c5
zIPpyxIe>Zt7<Iz4u(iw{c%+3BC27&+ygw$Zz1$`&TBUb!+@rHGXZoWbv-G2^UH3~_
z!zz6vr-EKWe(Ra~a@i(PK*Dsw0j|0L)LidgMa!9e-kPxI7&umxZ(8VjArCT2&kNch
z;)RFGzCg^4caM>t(o@fwRnBz0S0@U%|B;FlSm!zq-%D-clAG$h&%gSgcfgBM{!2dn
z__R#a6=79=GRPsshGCCgniJl^j?17%30pcrx29oCf9&+TPnv2m0z|5E*M)T@=6LW#
zh4_8Um@8Y$jjCzq80JlRgVtEnI68`9r($o2K?fBC)RZT>s<gRBQQNRiHm)kjYr9+M
zQCm1-NZi&5EZh*Oujq=JPTY=2Qq01FNPPrqUU*_<vh}_SER9NS>2`DVqmhnp*{?i5
zQn!D0b;zJ+-M%&uvnq;Xn33$CCAWcsbi)y^;Yin<VL|OI5ve9m&Gv}7$0R@rZ=HTi
z<Eg2(9}p37#;xmaG@B!#)=~C3$42bRfIkZ1DK!dh{={xsmo8l{3-9ITYN9F%AMKbK
zBwA2QMdTTS(vsijn_-Rd2Nq#qxHXn*sbeTdq`Ad>di0m*>OFl-qPaX$Keb!z>C^&7
z7Y}?XfYhzr!w6dHUxl&~D~IG*py<E-?s2r1w$}me=T{IzxmRX}*2&C3TX<PTvirW%
zkR4HN=>~wfA0QrEQP(}Yx=$Jhf&h8rLV>&tC;2lOF-i&|*drlqGpEDb6I6$F42Si>
zv{I*6Ert8w8|Ub|h0?O@*5I88iJ4zseWkW=)X5U<WL=tUtUi&r<Eadk&hiC)x_Lr<
zFCJMVimfaA)ZN=Z5Vg-K(ULppBN}#Q->g?TY^A42ib3QH2hmz}`y7w{nkd>k;*>Hi
zxdGZ@DrLGoD^OpVXI)tu4Q&_i#+mX~RqN7nT9fyjt82KTC1#!zOh=`q;a4d>>EF>#
zyo!jp3z@ZZlHx8%zeDws;y5Br7e~VH&N@@Kj>4DHc09=R>_6NoSa*o$RkM26%?xyx
zo6D=)s9JrL8d#zwP(KREzugFZrKK)IzUYB(-J@mPUOcdFaoI*5pr{&A9JQvEMncVa
zi?#VrW~MeazkU>}uMxzeA%e|STIvb!*(td7Lqt;CSNv3&mb#Kc*&4UU<}V(|w1)*w
zYD{b`OEgy2_kzcG_wJ(?Q73QlxdP&lQ-5tB(OGrhWW5UBXe6?tK)>ZZVT?#q=c#(r
z{xhPX<%U)Ct8q|QtGKoU%P-l+1ho09RsToUj|G!s3$=w;1S0i){g=(=rY`k%XwR*!
zH-^@=9qr3qt0*QdVY1$muRmf08nuNb^?kL46@mIl-~iM_0r-g0RO8*-)KLqO@6El+
z0Z(z%+}`nlM31QXs!B78;Iy&pJc_u@0}aAzEY|q)G4?sYKOoHd7*FuC8G)TWI)m~!
zul{QuHdhA9iI&QD@AR0}!*8tWy(|@J(_p-XBTm6Ya^)&=(RcRPfY<dz3S2o~<F9K9
zbcrz8uG>=sPV)?r15NHo9((XmjXF#3;+=9BDML@tATK!&@d9%lcqO3?E$Ti+pI$t2
z9~%&gxs``Rqe56mFn*|C54-^^=F0)X&~gUpja*n~!tvZDMQ5Bta~F7n@aD(1Ud$x7
z?LK#~6gPMz-wKJS7@akIf#zdX%}Dn^H@RDd*zwv{7u5|Zul_tLn@e{Fdau)xLwH|C
zcOd9%g7K<d(pYj9H589+7aQ}xM6%p2FNq)2Fqf;*G9KqCgizaB4^D(cyPE+}n%_M5
z7=gXcUA!;Ac^Vy?6+r5_z+I}0RaKghG4AF=jt=gxNijV4CMDq*haaDf*djz*g3Yg)
z-XHQw76M_NSX8qY5}Es)Jej<rfza`qow{|toQV8X_pgO2axQ{W1OcVM&zT}Wa^He(
z4C}mQ>ft~h62#CLw{9wq4@3#T;e9cIDoS`2u&Cf@E%~G%VlktXf5gtN(^Q<fh-eqQ
zN`P@=EU=RB;zm>nhtMlI=3YaPE6SU=-}BHL5a8qnVw;atG0<LQYm>w`$0WWvLTu}M
z#5WW1A86<39dp#pfii4=sy;sKqLW66hp;CcGW1I#lBtZ)dFKvw4$o~tLFDQOyg&O!
zdUq4ihV!hV$=yq3vJ>6Q_?4?o6n_=1p+0rpIr3DuPPD$KvnsHzDApnJru{6d-<#H#
z(3C<3&eU{?-_Bbxj;N4P|C-MRvr}K4rJr2<PSLFe&(m=aLufqnw&p!0;0_TBzpqGw
zp64FVG_-}I%j))ZSJ%|-%hyuBk{V5)6@8)InNQfN_}e)ifd<!g>mDMehAaGOp{O|G
zN0(}SkJZiLrPMw}3r&!+kst|rV#%&s*ATEyo?EO7T{kZ;Wo7SOmQ>Dlb#x<_bV}3X
zb39ZJ2|<#Rz{gISKay)|W-9#h=SUeJS>0E^3H=3{K{8Hs{u1`UIL>6$3{DH(c&O1_
zSHg>L$&22gu9HD&NfbYJDl6OUz}y=s%izCmUqDNZqr|XoDAujB4f7*C<O0XSx@9Yw
z3#(6&Dd7c;@;!Aea?Y@RS|S{vMw^CP-+aX$Y*Ckssa`?tJf|DcER?=VLg{x1?69~l
ziHQKvZX;{Z6hMkZF4`axm3l4mr=4fbf`<xk!c2Xr7Get6u+%S*2$u>U4`aXshae~c
z4~G0fsLH(W6VY|RynjkrgQ+IcJWu8pa0dzL?_-o4YjQQ_#u?d|*_}QnyX5Kr@czjW
zh#7`e3xrPTL48vc^$Ahx0~HZUfPGVEkskU$k-GNWyUMT(3*5qAFfgj3)$ALC6-th(
z`@F7KTB4<i(cl%kO^!os=5Wxs;o?Z<yaJn4!@BF`D4Z5;;szoNeie1keOACy($i1U
z{kP4}cw<<%RMhRG?;FASoqkOOGm5HY>vD6=d?Cy!8N#g5Aj%mz7OS%zNg#`ofeab{
z&C4<<{$<XCcxMyLFNnqznX6mZ^8YB9;az>;`Fdzw%-ku*5@Jo?78;yW2(OqvbWo$B
z7xseL)z+InD&%Cxk$QMz%?`b3D`J3mq69-^WS4T@`tmEhS-bxkfM$f-;+)#hMtl(u
z?23ioG_+Bl#}Fd2kNoiMGUUyw6T9C4kuBWGp$FcZ+@ST%SCTWlr{+uVBmq4c=01_H
z9Ih%8wp09fDEYb$`KoeRpFjsjpe-KgikriNdeh(7VdUsa%<gw;41POs=n(m-k8rHx
z`kx*wAJg#EGAlhHE_MFLuzI0Cj1Zi~;Vn5|(-)x;GdJiEmH91aKnx_PkoPVC5);3K
z{F_bW0!pJ@oBOc9Ne&e=B*Wx--1}}5b}bBg@s8$-SfDv(^@@jf81~HLuto}x8)Fxq
z#b=O};_M4qQO>?2PQcd)VMOl5swvS<C=7~n0y+LoacSfv=}fw7<{+sd_;VUyB$|+o
z)8g4@8fJ^L`Bp50zo_+oYH!UIY`k$c<{rkJkw1{Ky1E!Yvox^;h^hA(g(tn*UQ&D#
zSt{NF_Y~d*y1yn7fD^cd@8LH&Q}brbd=pwIaJymg9PNcZk|YQ3aNs??m@etTzM?b<
z$LOuRjdgSo12kqZNSYIEdXzI=d<oQCs4c9-<TtD!fE;R=RmH=b3(vy5V8mHQ8V86<
zgpoK)R*@%*^LN|&v;Nzno1YD8b*=<Bx`~m=0Zzbej^J>-aIv$NY4}aI{X28JLMW$_
zLT3`t6a8n{H<xfq1u8jk@P>Jo8v5f5T^&>b_g^_vIDaQNmBTrSPHp-a{sw9;(iUEw
zS1(7#MifVy3kwe%|Fu~Z=bY~o)%HePFoQ2O896$fP-3D$ax-M+v(3PMW=b7X7yzY)
zb$VNa^C&oFUiUoAyl&@74uU2(fSONbjz|?wxvXOzhMAfKmJQRUZZ}KO)3s1aY!odN
zuhT+TH)x@WPiUc=p4URRH)^384x`N43UE*@c9|lN<6q@S|I#wr%7IsE2+s(-L%eFb
zU0KqSlFCvkmiV+?H&X-DyQvC3)CsXvIp11RLH?Fg%V}l8G5ab>kHF!vZ85W7P_J5N
z1h#u;-YwNZmK;dre^Wc`EXTzru5ca%p+Xn`y!n=8=ev$0{K_QzXU_LyWZt3Y`xHt?
z|8M5|B*>Hb_LOqE)l2Q@6C=^Cyva*|EY_i64TJz<oLaMHU;|g8QKk|c*HL{+WLd9U
zw3h68q3*J?t50{Dfu_Wz#z@nFU@}Z6M}sMOK_l$xHCA7*i{FWTQJS0ryVuRiJ6n6O
zQ4U$Mrn&S+K{l55ZrN>r0?UYi%#JVgFaoqD7_&~0W;o)BiOBoo`2Q|7te?YLD(f8a
z5IfbaerbD7?1zrXHB7~$>etntH{2^Ll$J7IV|MD+bVsiFbRGasNkm<LF%MCp;=fH^
zD?b)Nc=AsZ17hBIiVS<$yTFS9bvsW^RwE~p!OKq(l$qF9VkAw&m>r>vSwuti&6Ps)
zV@ldi^!2GlH*5og2a;v&tsaHDo;iz+9x2v4zGBb*T`<xM*wqkeJ_2!p6JrcSkD(CG
z(~?g!fH9`A3cZB$es9gPbh|@i;r(pTwy`ub%ytQEWxd<+m0^O~4P$KMTbd0>vr%bQ
zF785-5}_!%N6csNB*33m95-)d2)63FEtrl^um<L|QT-|jilhmeG)$m6qLiSwl_<Tf
zJqV#fM(OqwDEj^%4wqt}ju4LK0OEF)7u(tJ6A_p#t||6vmev&gda~(iZDG+qqaY7)
zRHKG`2x9u2Ru&7j`sDNj#27Oo?*uRE9T%DMVZJBc+Ruc8M8kRXFO;e!|C1pB1!6(@
zA?ruw`|{6Y(#+kw?+jCvPiPKv!g8KS8IP`$kCvj-`G8L7rKq1*auOf%kB2AtUt83(
zyu7;0DD0bkevJRsxdk@B`ut^7n!f0@F{+2)Sfuw`Rk#4Y6&;(|4|N{<u_OanB|tG0
zP$E8y#R6FPyPZuyK|w_c)n;et^$IF*Tt^KShyuq3c5-!@^^r0wC{(_8(a%JIhq|6N
zjlZ-!@vP9q4xHn1F!}rXGG3K`1?q@0XW%iyIeDC%q8JOyX|HNkomhTlt5<h6dsi5i
ztF^gBs@4`ULI%i6qD*Wk%y2oW9A?(plggr0?Lq=_s3evO)iDEN_QW#XI@Sp6!aXY(
zsZf~)F4fIzO0<R7lm;4)4CpN*)s9DEYeC}UZ+fq*A6aUIzpDNoN)v|h>73OL)?_0j
zy}XQ*%v<?Au3hVUMZ274#$LdG)E=`Z6qTh<Gb;l_PBR;UubulK!8lwEBXl@F5j--&
zVp)By5{qsVORE)PYs+zFn5U<&TFK3LYE8`<na!40%Ag$)ab*BZJy#{}dT<j9V?=))
z(?-6JJzV52rHFZd^8j>m^Yvo)dUl)S8xq^4*!kHHg;Ka6yH0lLbn9ug0~>a<<c~2^
zk^G%Ft00MldW_x8f$Q@F)mQ7*U&Mooppum-LE>T^&)GMRq1A?T%Tm?DF0ruY>w{XA
z1-DIa>Mqbb2$}56uZ0fYtT{`>gC`r5edZhoUHW5adpt|exnj3v`VYik6ZWJ7e0#Zl
z4urAGIZ?g)ii}@iOGf#pWrPA^RywyeX?+uFZp@)R+poJ$Ub8P*18F$X>-dhyxeXgH
zN93p+O}_GoU=o=fSL;o?%LIUjxDyPsg;**!MlQmW%uYc-n>!fiH<zCEJp-kZS|*&&
zF3+)*sZTU>pLny`$}VosGpJmkC1r1S@nrt+GrziM@lAY<S=W`+kHas0Td;34yLvHe
zB*6stq6CHorJ4Hg(nA(raqEua?rN^H2yKj-AE|F_7Gva^+hc(b<$&OBX9x^*-SuV@
zTwO1#20Yj?^8YD^m};Jr=z6%h_Af%Uw=RdY=(Ft)ihj8Mt(cK+kqrWjFEx|;=>R*j
z_`I{FY<T|UsCjIUd3mN>)2{NwXF#PZa8hgH<Fdr^h)>0J41sCk!)a+0IiLdb!+W%Z
z7<}p&I_n1M7f16Y^c%O0i_~vK%W5r|-(&tUbGf)!>xSG^^Cg>5;|bcnA~0xY#$MKz
z9%)xUn+H1w?Av~}PWHTa02($xIzEWheSNML<>)+O>MmN1)ZNon9<zsc)f}67-)p?Q
zy2A)LF}o(8xHGX>;^sHbY4G=Gd&1B_Z0L2RwGzxF@Eh0!{LJf0OeadB204&{P1;{w
zZLg)y6EG&^-nX1A1_~Yuwa)=pMLZI*FILGi95WfPo4B>)I=<q3>Ktnjy{M(uP~l~v
zAR!w;+hm02amo(}{qUJXACN?bK30-#EbyTa$9Lea$oR+)g*;}2APpn@*<E3e>Z&hf
zTdsZDD>APu!Ih$mXBAx>gunM{A8gw&xxvF*N@u7DWBA9Ht1)vQ`&+nmcLx$q`LN!#
zWKifb`vmQ404I_4?>en;Cr5YeA9nYE=cZ+xi6GARx{{8K>S8J1-U)osquL8plS=qg
z=h1fte*)JOj!+t{Ev?0jVudz1=%lEwTZ37m)ygYZ@rnTTbOH8pid*{&=(WY4l~aD4
zF>TV~NDnAq73}9e!dnVE9xr&9d$ovqiX~tTmCRegi_8gLt<0k}*dRpnO2SjQIcm{Q
z{PriKANmQTUD+XUHcjXuphW*3T0RX?o=O(P<kcBKTcQ^Sh*MfgDPk{jq|_<UA;UdQ
zNvW5mGV}hfn)ly)DOKu;C|MCM%8IB(84<-^)@{Mlnz?GgqZN@*1b8bt?nU!H-i7{<
zO}Kbagh(jtd`~(pg4Q`$sc7)w>%g%RPqSn!zIghDR1oP`AX!S%^69lDJ{@M{Qz`Ok
zy)YJ%R?VUQX4+oniKlV-lg%L_oxJ&|MJ4%pGNQ@b^NYB$`V@QfAi72_$;#EOQx!xG
zl_HleqQA6UD)r>jemb4p@XwM*Q|aJ;D35+I@lf*Uu~$9D$jBq~SVkV5BVaqw3aJC`
z>}H{Ae0g-*8EJX+t}sO!%;uxer-BE>t)=9qw1Y&^cNLZRawtOwNFqfCD|3n9mk_!V
zLg)BGDC!ZGFNBtg5PI_!ANkLx?a_nqC35JUtbX+Hl^VxT{{eYq1dFo*DZ+rTGK&wC
zNHGSHkx2hR!$LRu0rDs)BmHmX5&2+{N7XpqzGSaT#S!=t=?dC~L%)keiUv<toO!kY
zUnJ7BpByBNPIrH$2I4V+qJ72R5l<Y!0`|Ck_sef&unNCu4^>OJLms`)BVQUVq8}xV
zbPi>UG&)_khL^e*(18;l-$NQr#$LkfyCxmQ@Xpodw=A{4P)7w5JM<pHXo$F>&tI*Z
z{exQKLAXUGGgwOyT${(1#b6;jiJ1PJ--+(N+Jdmu@t5J6Sa;-UISupE9X#hFNz0-o
z|Fw`B>Qqf$UP;~@_d@v{SeI~*TD$^&UB>_T_KLJY1$o3~HElgAE(n$2h+A5R$4laR
zU_aXgWpkGQn68@k7l@V6U#;<}W54nwQ%0!uCll9=<pp`#vSHW8I)dv0Z@nyr3ljCR
znE7^SUo3#DcBB5b6ET-3I(ut#&te$F3TShe9-Wux1p&-mAz!@!n*=8kF8STu0I@c&
zO6g_8HNG~=*V(^*gs&^*YxmZ#inO__<!j#B-wefwTHf3H)}3fM(p`(3hOgKMmV84h
z>}&?A2Y<PiI+`z-%V_sE_6b={2oA|%`uQ{o)9X1#NS0p&)v50LhSYtXUvr^RwL2DG
zRZHSPH2DT+9Jq)RPl};|6~eN~+msJoDg4l}vF+E4C&pe7TVWi`L}2$7^Zj3VD^u!a
z6q03Kb74t2n)iADsraV{o|lv3hU^oA&GjCpg;Flm5)%8viQeSHz0nMdgkA*g_J2wO
zm^oczX==3HFRwy-yv4w0^I+3yZ_VktTsnB*cbsC>MbY7yDanhdZ+c+0xi5Aa8gfJI
zZP)zV2)z}P2db9xe_ujBX?}rtAS-m2*&bTWPRiTc+Ga3cS=6SsK|LMICI5|<+{Aar
zm>L6;2en2P$=F_goj*%eVhnrOLktL4QNLqj=K7en_~VPPI0JWmC+3rJ89hdYiW?)?
zwMJ@P^_P5MYjW$6(NL4<&bPP8BJrebMjTK6w947A)bi@D61$FiS*Tw@6zc!;xlsS-
zG3z#={5AS5Ydp%A&Dyd#O^WjO71;gXkXt*6e$uU@xA2Dk2niCP{60;U+Oj?s$P3{g
zz2l>30Czt>ApQWb>!gU8c)y!i9xC35b!?+cTw_hUFN@nVPYkH+7ja2P+Zhink0`+p
z#~AF1yuFo>%9z;Iq1RYM%R(o1S~rYTd&6S%lW<b)c(s43SgF=n410OJR9mrF%q_)C
zwSyNQA>W0YY6mO^86G>;_FpW^e#K81d##sruldbT?cwFHlkksq?wWH7pa{^0gYTkY
z$$St{k(bziq&Dwn@Nce*RTa)P0_~FeuR@_#r)@b2t8lB(3Oe&pf*gE}+4pq2XDC@*
zM~gYq>1Dxx19(li;Avg;SMJpm3~F5_JtJ=Fh6VExHiIK_aPHi}3@UC#-(}BN>>#s~
z^_~4{(F7_>+}VPe6xQ6JFMi{7?;ipPK<XXr=CFOWy?~8Cf*$TVT0Rq<$7%EC3(q9J
zMkswuw=s(C(H#A)U>~qayI;n(Xb^2i>I1LHfZS^S0-r&f@L&uc7!CH1K@TPFb5s;K
zC<H2`vhRIi0?z`yi^VAmCizkpI}NGGD^dIU9DkKPyjwgwROplF2E;dt1yWV`iXPY~
z0OqLidy%GHz2mp+O^hkbi#6>!D{@P-$UmPCBM=YafKfK(-rlAcU~xw2WU#revc9@6
zN8>hV3q*eai&%)%d!1V11Bo(a*%4#!(;$Dz{U1|+l<I?-5vhv~>L%O?Cr}kBh-I~g
zmowaL-`h3D?ibcW`_g{fy5St&;d~MXZ#e<Kg!5b+p1nO%7Y=I+HZljno|at6x0t9H
zA_51qJAql<w>!|>c5-Gtf)j;SLQO2w1|vF>zZDhJBrDj9%d0=utKN@=8H9Gf#EQFf
zvUCJofQdQuv#WtgSYYzeS4HkFDtPN5@A<83ufLV&-{W~5n#6tcfai(L-x<O43wT}u
zo2b<3nfHNv5q+%s(aa-#xIcl8a(^yuWc-bbet6<b>*>tUo@=MpxwKSr7DK&J4Yfk>
zM;mX)Zz$pEnLKr5BH1`D@41A{@%)U)t<5*OA#adLsE)OU5OlWv(?{5a3j>XAk!l{f
zSZUvdk6jiTgId*vT|Qk<G}u7x2(_WV2E?kMzCCczsyw$Ig9d_$c;Q_>*|;kyWq%!<
za}W-CHL6+_DG??3nEj)G9_WU!`ovD_)ZgBnXel32Kdf&gyhU3;cB#C`D<pXFZ}Iiu
z7qQ1GMLQt0J{s;+vRsR=wfhy*bf3U#BfLqQdrK#jXufZRK=Nx^;z#^6LR=Qe&yCaj
zjj?Awi@Th-g>CtWNb)h&{xlw5q0PI1dhyW4Sm3pIc%ydz>C#G7C!`w|(!K9Oy=qSs
zw&EoEAkJ+LqRr;ElhXEaT}0^C4KzoDZr_A%!#>^K*C)~(7{nr#&B$=M&~J4y6uDp+
za4}c7)qKE@48K(BQE5;)9ONG7l}F9Zu&M5`DGREzJT7gBgjOi_#2ngc1UjMhsQDHg
z4>z=81-zR#yuSKqwvAV4bN^GAg~QSM+aHUu5CaerLc~$2d*W41dT9OScC;vMuf|Zh
z0YqA}HV-!@aAH;46z4QQY6b`L{px&R)mwG99o-G5FNf3DO(QZe-QoZ}usjxS)#e#s
z&oI{;p;pxwk^2`@lBI9is@3M6Nf{@x36)x*-G354aI_8;zMQ*Dq=|TXwsF5N%fik4
z7I_Ff0EX}<zzF;7xm!_fozS)ST=<jc-}Bk?tplG6fAahSpFN-J@f`M~3t>+W-ikXP
zP*sq}!k5wse97Z;eYVWR3wr$vU-I-!pDoAsXrIQtIPYC&2wRH1Ke<8iW47JXJ$5`n
zo+&#eVoxhar&khJP(opY?5~^4(T++lW{ouSbFaRq{|t7VzH*-;gFx2e^31rXJx7cs
zBe2^26NKJSX;0^bJd8LNQJNoFB77G$J3<=_*ufrr@fdqponl{}i<@tSFmB?u;NU<!
z(CRU7+<Y7Ut*E~jm-%Kbc?Bz-IG2&FQYOVRu_fGDbmfhY;Lb?hfIuv?9zxXS?S$G5
zbB#MoQ9bep#W9#8t`Z`<U}FcgU=;?(+I^N01M*lruqJB%sN24tG3+%?Ta8tzB#KeB
zC6Z_=A6ajltl~rxvcG6<QSeiC2c1=|XOr|@_~8oHc+b7fo@4De<#BI<yr<vISEK4J
zBh+-cZNNUErZj)Y%oW52t1Ze$nTd`~$teUR3=j(M)9!y&3ad8M-FCds7c?%sahAli
zgy4yF)B9t`#ly>|4>ru!ICg=^p5@aCcT;w#-S0bMNSw$fL%tr`tm0gDW!I4dWqD+y
z?d(wiYFhwf!FlQ#6f9rd`@az8sAC8)>}!#_P#_*!A@ljOVZQH1uu&Uu>AI3jA!=^)
z#j}VFccn5jfH!uH8>M0o>X_qR1lqC-Klcxr^D2oJLLK`D0l7DRc9`k}XL2NoR5qX}
zgBvV0L5tX2QFDu6hf9l~ACWOPLCbAyROBfWXBiSF&m9lBHYkg984@AS)%mSV(Pd(T
zx?%Y#-<F9P>Ygn><=Zl`MBVSmPx+=Yi@SaJxkxraU5jtdUY$jPtW>;}2{P^Nk4D>t
zN4h@-g1Hf%Dn9OivcLUI?0>hvy>gTg{{GDVcC?b;|KIL!qY>HPK1vPj|6lvt9m7Rw
zw7A+25Hnd_BYMN%og;?wydKUH6&bZtOP<IpIsq9HpJUZM1;zZC|2g=P;De2B+2Fot
z{Lk3Yx&cf})R9PFu`GX21?LT*B`5RQA$I-^6ncC1k~f&up!3}C1AbC4sgl|8tKtq^
zEqSkW02|{`zOYbvlxwcTZGa11?eY8j;xd|IEjg7CRte~sDE+a=C<B<_mxWZn6WF9>
zbZyUgeCZqqSGWDT!5PC-HaPEr_?_K+XQb|3yy>3IAN)%anM7Xn9qjmCDnq>5`60C?
zYv&c+Ju^S=-c$FetyBgjU&OgXJc<_tR>#otYPP5_UP)n1Jl^H-8LsHUAb+GTYG|3W
zhLJ48FF?F3A_;JAWitpUN~--20jm22o&_0JA4Wtz`g0qx2)uxjgCoLpbDPew87I0$
z-jNdr1(|S=p1_oVa6<Z4IQ!@ypd@9u{|!A<&sKDB(b7{`pj)$4EX-}r#tIdUQzZyE
z$45Y-v%8wWkN!kx<f2eZ{f<s@(df%(=R#g|&XczR3W3>07pp#oIQKxjM2(#3{M(2$
zoHo!Qa9RY}DSf}nc@e<6-yp%9d#NP@`IUODnysDP&YuLXAm6!89<uE+s8tN8smBNM
zpcTHIz{Xf|la>+}PTOP7Hr2)|_jMYS$l!PQ^!Kx`ep&W5yl~b}{a|6;UNQ-J9W(bz
z%+Hm?u?<0B>*kBA(b~HCP$M5X%vHHsc14zSQu>Adv~H)$=#>~ZX@fYlr_@WScKKze
z#`BCq@rh<))G7&qOHJiDA9dbGgZJ@-_wl^<(a6UaT1nArZW`s~=e;&2NsD&Tf80)C
zORAGPvfk!vIS>4=Q~a-AXnj*9e3wrkET5HiG&PR57+i&Xh{5%u?6=Xxcs^)MdRs?t
z&irRMGi^Uxrs|QIj9BJpx5|TuWGr^k1q?!!zBoXtSdV)(Q{`TBvH>N{IU{KYk3C(M
zs;1~NwNcuMOFNcVYAuoajKc9>)6K`Xs_LnY@&WU597Zk`yjf+kT{6CBsk&p=O35n<
zzd(eq(m!yPfyEes2$o_}Z4M%qLfI!oHgvxzbK;#=N#teA%!#_<jH(uTs6zU%JW8+>
z&KaP9PtEIJD+77g>(&yf6&WwS)8x}Qi=00Sfny6u!1m+JPkIMB0wfs(%djLj^5tP4
z<g_M(W~9<qo1W%p<a3Ky0q|Tio3qz+Hjmuj7lcir)*>+4&2Me8IkJ-w6yi>F!<@`!
zCta-2l6AZmX9Fx|U0x;;9C7n=Z>o$~sFz?1t9FRv5>umFm5;=&$rV3DM2r8W@)34#
z#xUri3LCY(K$xHfP)N`E&=;rjp`|7=0>3q95PN<8bC*qFEH|;gERVLV#}y=B4$uGF
z5cyAr8`_AeFAX!6G>~wj3!zvZ32D!fH;wg3CvmFpV%M^|BbKfnR}?h_n)>2&gS3+;
z1%%g_D`QRH6yRa_m|GsSc`?i;J+VZ3$-8faFRzGUtAOES_I*SNjjZ735I)(<;JD?C
zVYK7z#-IBH7)vzkAQRB;jge}tW~FRUgkO~2s#zj#)UA6<0sR2)I<coOmB|cMv~V++
zbABTQysn2Imse`uH~=J;H~#{UNK7>?jv7=C@#s?;w@3JmU!K$W+0ytWe&a%D@6fOS
zITJusrfMHVd@HonTm|tLCsA9s9#R;!mNfFquu`j~F#KNiIR;B+v)y2_p?z{NM~!E4
zVn#`KP2psdoQH`<5*{tD*};tl5<1f?e?FFg8VBqMeGp5tGG=nNz)H>FCknQg)Il?j
zLLDpFN0n8SkD4UZPk9;T_0)wCWOS4aprpYokv1v8fs=Z~E2;BJ*r825;gv{L>VVPI
zQ(lS8ixQoZ=e-iCO364%7I`J|fRgc)tm7+ODIf3;3y)D#3F3NjqZETHJ{a%x88LHS
zz3^8$TI(-DG}hx&g&{~VMAEf7d0oQ0tnWAv$<x%Pns%BH;SA4+9LGGi`>m3C&gmCt
zO6h$D57p}}Ds)<X9lAs`04A*Nbv4BAs-M__en02t^dtI!eg^dH=aq1#lzxy?>3*a+
zzaP<7^s{xSRDC>8+F?q${j8El{(L$WWR|q^ku#qwy?&&Weu~qLx1^*wzaLSR^fN>C
zlM+19ouWUKQg}r*EXhK(PSv);x*Z|x^i6f0)I?TLP6hA5oMl|30mIb%71*ja#DJA{
z%T&8dgbcg_%`0fg6m%(|E8?W*Iw|*h9)S#1c>_JMTIz|^>hH!pBhnQ;RP#4yK9lTG
zL(<22&7}wNn2*;?pFfuZyXf>seKlnt?>xdhTIM|=^W>kfNGHv#20D=1yavB)xi4s8
znHC`tT9oQ>`z5J?{F@?u*hP=uq|Ak>{L(^|&pT^4+svz?))1}E2P#Lnr~4O!3;D-s
z6%IIFi0V?BlkJq2dH((wiMRWD$Mc91RO<76k*Ay>_=w5NSQ~ZrFYTM2AhMF7HKIzM
zM|0=Vea!rwv_b%Ox{-#AF)NDrdPJC75Ub29Te{bAVr=5`(ty_Y$H<ozWoe<gnhD5+
zY4LfPY}OXIl{QqDn4QPy_N*teC*{bVIxaSFx~?xup970{2gf)_*i|4iW&1qRqHYYL
z(L5%-RX+JAZZH`$DlN|$aHIsOj2aiSuGb}el!H&_w_W4e4=e<Z;(s|U-Yg?7Wub7n
zobMdj88cscgx6!-tP+Y@-uIy|JwZ_o2Y|^d)8SkW=H(^o)cn<#_bD+q>t>X)bMrgg
z0nBZ6W(B3CelF9sZ`%0dbO6{yybS1B(L<<zSv!T5BGghp*@sQNfImt;pn=4Fm3mrA
zC3|Dq{!vy6_bT8=aDRYD$}cBQQ^Hu$0hkggxlP*rEq|bZ`=*H9@^|#-kc))UR5aU8
zA?;lKxkL1)ue+^>%0TG>>d;r?93=>?GwgFXE~xaQVf{fUiX*4-@K;*$olf7rh{??|
z11BoFjS&S<0(b=&AdjUi=h(Dl45Rpfqr4{zU?JgCzMmywp<T5{rCyC$SNn%~_gA0G
zacww9!P&5S8xm=sXad{KEM_l9LyqJu?^^E1VI!Tha2#74AVIpkKd~%^dk6!p5-S63
znras&47@KVmZ1M<#0zCUUMdqye64Xs6!*GIe7&kiAaaC5gS0h)-LS+eJ;tVcbD`{!
zS7PKugYA5Q%A&zefl2CfnsI*z1{J;$*v)MN8ZgMj(3U}!a*D}D_{bX!hjUEI?v|hE
z*ca8%%nzLXgBgvb1||FSrS41w1VrJjFWGW`jeat}B|}N_C0Q;lYWZ1z`40yeHrj^>
zXn0nPE@zRV2Q?>khEneT_U8yl1g%-02IW#9SJ5j59e8^BXf{VpS*3d@JwZB53oq|<
z_E<WUMd27aGpvVHt0J8IL)vlk1__$RxyKQI%rnk9T;!n@_b&AO_wZ_X(#%6I_L4uq
zGTpvs0EdiOqu;~%zgy)PixJpb-JAR9ysbRL{Da_DPNQk_5F&E@Hpg|_AyLB2D*=LP
ztA04}x209F6AkkxSnEx?e@1Nt8x;}Eh7p~7^1rI5I9Y<Y0auy&P-_ccc~zjT()dC<
z#Vl;xjD30(==HVOl}^`%GP-76)aSeDw$hsGBOdx_I*3PArv;wnYARdZji6U1H+b3*
zF{zdysaeoY+aG~1=jpWM3G(avzMS(W?2)H<q3$kqcEgToNH7XBB37c}4l^=<fD}nw
z{o@PNs5~4f@Dh1m>b?RLgzllwE@&=GpQ1#DDs2RvBKFb>$bDR7Ao@trrAQ6;dLh<V
zI8*Gt__=BVx#~PEzZYbGKPJDeto-DVzjkMtoO4jB(|S=>R(eZB2_jDVXd#wU{%T)|
zFfH_lNetGxVuhNBd`Gw`-Hp#Eyt4W#!+KUJYy0H;dKKj1j|YB{y4eGu@2={Tp&YE_
zmgT^*JJLK#O1%Ta%e(urXGsu#W4T05gjd$A1$@%J(1ol`<(hWqNC4>mk#7nQ9O-oT
zC^x&$-<#ZDAX}Z}dHk8p9|GR%uE#w%4Rez3)$;vjzB@Najah;X`;vuHI_P|nEzRy<
zE>S(Y8`S3tcd7q*#-&oe!o5m;wz%I{UY!+gZ;VhWFQ?pn|1z(U0>AJz|MLqzJv~O6
zh}k72+Pvd&^2oVm`}ndd44(AO=^1-bB}`bMCrGBxc_^*^eQ}~DR?01f;8m~cg#@l&
znJx6@&&esNlcgVZluE0AEM4&c|EsL4z45$F4R1W}-0+W#=izjVx#PJ%Tln|K^TTw-
zT<^ZnN&1dx<zSq%L+mfzy0b*QpAt5e<Ht&>3wY!N?apcp+zv@aMP#L83g1I9f!#6l
zGRZ{6d6^R>Bm;jZiCyj&*^5(<CUJop?A?r8BJ6|6E;p=uhe#$`>=2~v2=dSlAd^l7
z$Ch~=Co+m>QI*sUZ&l`{aS{O*27=MBj{Z$=q4kZftg5p5V9-wJy<%L<zPt+;K%{=8
z%Aa(SVgIaKQYgupSTB3kD#>2;f$5NV>FaFvs<<^ykJ(p~y=pi~qVh#GB_s6bH%l|p
zY<;9_k%ZO}$*+c`pVY1;{)=(o4>CCv+qL*c88k5$6>`F8i1Qvoz<V-ijsJ|S4t9U)
z$i29|1`1D8TOu+CFn0K2r9FbsD9KR>?1nI@!T{&$m{4XC+WgaCX^#2lPDD%f5k9Yz
ztXKJbi&?swkUH+?XT918ixW-fwyMt+i*S$RLiny9(_=7_SXo|KKN(l7mijj;2=+js
zV6{Nm1B}k2h#YJ4NvSwzr2r)-+E4gU`g>XWvyT1<AypapM5Y-b*i@y&B16$g7B35H
z@+y*h?<*tKSB18;>(LH!VM|V|E-xpRLaX3(1mHLge9Az@FuI<Z%9(fMzYr5(D|T);
z2k|hH2Z~=*UaZ|`Q#2KM>wI-C9$pz&hW_=;k@4||%D<)`kbmt#5pRdizjl%$_z^?M
zzgF($UxQQ7*f@&_`-n>fE&!ASY+T+$d{ju$^T}(EkPK`pO<KkOS^hOT>Y0D7mr$@I
zcBA1;{xy9LQ1Svq|0HNL_r%zug&B)g61GJvz8WxL!Sb)juCP6yI4=pv;}{!pclpFN
zDCaCURFHcz_V?1WA)-NRZhE$UlAf)f2!`*<GexMSd?P)ZKkjULHi>7DglaCIX*n$k
z+D7LlXq(UAa}u=aIpp}b%qy{Sd=4#2b6=?DJb6iewjUJzZ}PJ#937mWO^$vD5n|k_
z{A_;>L2?r*^vAF0@Me50?)yTAx5N3l5}9}gBiJsh<Yu6TE39QyDU;x8M9g<B)GOIK
z<6LcFr1w*ks{1FlPF-BaGpc~!ykTXF21?D!<@KZbp|rgDb!==N)$d%t3hf<uf3HMR
zbL)d_dwt1S^>@h%_al;{e;puoDXuD3@SAFel8A%rF5CS>M6?Y*+k?L^6}D*$FOU<i
z51vH=w;px8{;`=c8M5+OCEfafLv@&u0q1hqP!>9Y_v7I&YyO4{_HXgPr)>+e^&{6B
z_O<=|1T9Nsx^gydigkU7HMVDZ1QG)omS%2DtPW^P8WZiOhE}nw^khLn-Yq-V7ZPs$
zEfIL{4kbl{HL5uAAs15KnTPN+sy<aofV72I1;g6H>fps}grAo9SgWY74r+D#SrE!u
zKTtZDcy-oI58TbqWNVG4-bj4ho>-e-&%1GJP?VV0a!v@8hzU(309VjDTH+q+$3m+l
zZOf&kMqNd$i5vl&_c@c1t7hc^2cYgNPHffmz=mPO^_|IhhjGlLRz!(J_ukHG<#K!Q
zWpT{1RK2W~(4!Sx%W)<lmbIgpsFhzJ`vd0t5pz>S7WcdJ3BC0KY}_+$U4J715uvxE
z<_CdR?l;pG_9?C(%SXSG`V%8_Iz<jlUy=BlVDeV_roExG7uaN9>D9TGtTTnB^`p92
zs-%`m4G!=~Fbruwb~!IW%Ay*^=kVSm;&{m9Kl0OaSFpcuj2yLP9mMufhr!n}A$iu9
za!R$kuSoF$27k&#;ULc`cHhhLKhe;;IBB4f&57G)y4-2%QH8|G5O20lOAs0gR5yT)
zScoOTy0~?DNt`ru@u7E=*5X$=Lez4Z%IToGr)LyfH!*oq?CB5+;^rMC@d7Tk73gyo
zngt1vXZy;7d@S&#06q?&jty{~RVH51eBay>OYArR_Mr{teshcYS_bx!dV|cYKtEF7
zFF2=Lfq$g}|Gx`zt)f@+a=;&fz7zsveJ?0T&S%<V?ZR;4+hXnhI`s+(lw!7yr{N>k
z_<5!SB#+?RRe7DU(CR3Mv&mfeX{UN&9B=b|P$TCD8Zo?voj?$D->`GnZucS|p0YND
z#4h%bv))nSOd*T>FW|&k@wMPwVUESZn(FU(NaLnQ^F5~)sh4>ecx$xX$D>@fcs=-`
z{S@VnWvc7D^Kr-c^2*$z==XzI0zGp}w@1Ib&$xBNjpo-G`n?Cx4I2`vpW%bBBr<2e
z0%4N^;ZuSotLSdp%}{Wpew+`%3Pr;&PzNG_gHF>2V&^hHr+q(Sc`&pLAL(i$iZ-05
z5Z9jhBUbKPX+BKOz`rFDLnCm-`4#HSolFT+i9#;cAjCy3@o96#eeK?p)Ban)%Il&s
z-34)nvA`N3w&bs*rq?_b_dA2=fyeH>lxN_j_>hUHW`vzeoe<Md!<86DFmsAW)#h5U
zS3u7Di0brnzpvCo2M{(srJ`_GeqO`>F+C6Tkg?<29>_S5o|i&R8G3#m!6=OX57ToU
zZy$!9Z{m^YD>7o$6R8X9442BVO+w^v#okqgT52T{S{|Jxl@}fnsXu~p#PEsyHg{?-
zMbGP+%vGi5b-6{VIq*w+k$SHBaqkc!IMr`xvfq#-GFJ^rISp;$cTPhCy4*LUhBvNA
z{rGNoiXw{&(xrOzr1;Lcw9Mxtw^?<=JY?kaG9y3L?{JW!l_Tl{UVq=^XSzQ#8tQWU
zs^%HD4_CRdTjazMSvhe;r}$z*tI3p-l@!M_%)>x-zvmATJmHL?y={1#0)BhQ_y9i%
zm+kD)p2;+_?HN|#35HpCqLMrU$jJ>ExPGQaoQ8*Dfbvs42Dp+())D5;h)KBcdEbDU
z0pGYY8ID(YgkN~xH|{llp&5`eAn}dci*B5~teiYP?P>pe>)%7Hc}dl)CI0}h6T63V
zQ1yG-y!&O<Yac)1%6tw0EhIv^a52u@?ya1Q9@J`XOv^JugPWX!8un)@$sc=rY2A$8
zd3PT>bX?)gqq#>SWwZ8D@&aq5#HiXY87d9CvLDf<mk@^VV6YBUYYUUXpYw_E?<L<&
zzGEv4!!()I3)AF*V3HEdtnk`d#~D@Y(T}~#L+g#I&*OpZ@jyqivF7;fd+mwU`So5S
z_&K81lfgRPCfg0GJH0e!4?Z@|t)_|Lv@Dm6DDyh>4u;DPJ@AztenWCFu<n<|7UEEH
zBgxvHKgFK*#<eL0{6VwKpe9-W{6S;g$hcvMZ#k_b2F~NmANOZ9C$~t7(d=AuI#88m
z)owOQ*>`4#$q2|AAPrBkY`B(cYcIT3O>G7B`DFLBA5`FBQ^+|Nr(zpN<9Dn3az&0G
zyhwdX&Z8Z)NF{lwWa(qYwoN4?l7y(!fq`@O$+BAB<{aB!hDN9X8tk_o%*-v_<1i(*
zIp2ex<Q8o4MdTqjynPrHOt!6mXDZHS+K~Fq-%-<~t?qH95tGCz+nhb{x?Gu<e7}&8
zW9#aYMP)Q5_jJ{%PxAWn88urIYXd|8U#Kl<P3$?9_*v`tWu5tXw=^mvw-Y0Gb#!RI
zpC>lvk=Zs*;D2%{htXJs4K?=zy1M<dw0Tcb5)Ex6DweaD;jY<7yT7DF<Waa|)~Q^*
zM&L|SAk<}qIsJAwxYCw}%}ydchRv$|P)ON|b7Svv!;be8iiLQ|ZM#+yXHFGs_HHsG
zObFiN(`byDV?I~oLm_G11EVnvp-9YUDkiona+Ft)rnrG_3y#yR^P}~*1*eELJyi&;
zoE}+E8C*rrpNc3&<D(GV1i4dpk`dmnB|`Keecl%fy=z!CC6McfMqrN~AhMY=3`^Di
z%|xhjR<Y`r<k4bni}yvy@&6&rTgY*t+AYHeBMAA)??Do-gaM*s?-4uqtvx7kk~Bh9
zm&46>l-Au1H=in*$w>wrAvv)*va~sRLcelt;SV@{en)BjRY&x*Dv=0j`c?9vu%;7`
zvGmyE@%v4}?-#-ENrmgb!|&%p8ySA@K9Jw{DSq$z`~3cZ>Z2#WuhkNJn3lHiw?4mf
zQt-L=Ib*DcUps)`*`^amP!E33c!m_ek3R&z*MJ`Z@Dczl{Qe!q@1IFq#g2|#7xNog
z;c-5e_LEFhXHN}85&3ufsQf&@Sa(nH3|)&}bmvz%Ouc)%F>yp5e55rwWV-HiO#P80
znal`;H=X`?;@u9kwuiFX49Z4=vOOH_Isj$09?B;ALOc(At#@knfv(=ZcqXwX=<0W=
z7V;qZcd&IC3L}H9od;sejR*F`1H1oM*phU|Fxiu7baBi2N32O=;n#bh3z7Ku&{Z(5
z*f1w$(PgH^^Y;*Zf-d13iC6($xP}n*g04qJAZF0jA-h+p<Ds6kpsqtq<)!6x06D$B
z4KYm)XO<TDH+DM%+65i2dUR+fgALSIQ5s{hHk{v_1jZ_rc@zbF9!tb<#3sgJO0u6G
z54|f{56Ej7;N;?@l6c@_W9Ycj+EaB4GoItX%Bn^+iAp+Fj9>WP*G7gpu7o=iWKO6Y
znUk|t$#qF5uVy0aM`n`dSGAHx-}v+B#XSBjhEMu=?)bz{z=lRV^j>;=9Wp+WocGg*
zPDu|?X-iR@nE@WCF4X|DIx&<Upr;ep(u*2k9bi*%CdElcANH!*=@v7<Lyb@N5!va9
zhc=|g*QHzIOJac!{xSF!jE7t>6U;4HmHnCXbEV6+D3uN4%K6?5;~xFOh+M`!dg144
zsRv#`prmH`*yG!Ned|xG+2M{=yYy;a&IqW?O;X_5X{Z2Lelz6LUE&T>)S>E`d!nJ{
z$SdVc4GpA|D*OpSPi8$1nXnG?Q^L`&`n}gbKA8T!(|rMxQrTe<J039OrNf(}=k_a)
zm~XgM#5rI`h+R&$);-SCWS2uuxi_he^K?1qjD<Dk^DxaC?j=Z_2LC;b8+m?5?(^5b
z$v)rXT<N!anp%LT+uiOA^~=2lLb`mvbGlzH!AXpdm>F5G-=nW@Q*^!A`R)z|N|ER?
zA+-Tc!((E7>{2>SDup&X-?jnesSG4dFV1VA(;d&`Jh&U?r$$Dc3Zbsw$*~<_Go<w{
zX9@2^48mk0y~PVaCEu8v3MZ$Zq%FGFGlIfvKP@M6>^UX0I4-x#xn4$hF$l=wljf%q
zH5Ohzt+yCsA=b}0qp=YLz@B{|KJ0M^7zv(1p-c?xe8alEWVGG?Y<=j&(%L?`l%<;!
zON@fsi_>tEyE+Fr<A1|2#(+%)=hw3E5WOexPQzof^X&F4JcJNnmX_)>(#lTBCZU6C
z@OTSkl-DU&?MakxhI=lmB_CIg+MBV<S9`)ghtPW@HexJ-)-xG~8^9KBh?}qX7;kJn
z32(jeioN`;tKvTumU74IN&C!r|9Ij-<MpKF<DM{5%Gl#a-#*XEeQ#7o=rgB*&fHtS
zRB+7dXfzbU*_p;efF+WJYe6aTiD)2QQ=X=ur@am{@;5D?)AXa{pXwrsNC21_;(gO8
z$#&tbH$HRTAjBZuI>PIQ9>S~R(p>N#y^p(28V)J99#$LTYW}(XJ>mFM$|{?Q>Ha+M
z$;OP5<rz7iqh}(t+F+0D9-%EYF6@4^V_$@W$=(&772>;6W~nn&I_bgYe|{J+|5l08
zinP2y{$!BpY6l?Gy;#W*HGW@SA<r`PUp}b*kCe2`t-nV}1ZTcqRY=-BUc^dTY*zC`
z3M-^5uW-L}y<aGa#?pe)8SNK-LLpZhx;9{t&#(CHTym^5v&wB%>%>*=4*zp8pZ<Q{
zV%g60Hw@%#hHOUa>=&@B$BLCbFP8Ux{ESr(cw5?Q^zaA9Ngrv6&#-$2H7>4_SHkR4
zG^x^0C|xX9tH@S`UsIKd&rua@)e_sNq@wh;MwWn8S&p||I=Nw~q=yhsceqPGX}6Zx
zK{HDw>q<^pyOc@#m7KCKDZ`CDh{(U@#d6}E&=4l>{FUw9rIO1fYPu{q3P~m+O^Xo3
zf73x9cRdiRBH3-)sEArqgX}#T_KY$~xr!kRG<c{o?#mWNOj~FKN0V>@Wn7PNQd=H7
znF8V~Dr>ekW|iPkC@wcwM?)_4^eQ*K{SnJ-f5Z&yd=_~X#KE!q5hn(HSc#n7OuQ;A
z6>64M*X1Ia%LtWh)^QGnSJ#$N6QHHH14zot#;CssAcG{zpc3me8jQsXu2$P4rrI9a
zQ0SSb(*ct56Koc-X&0Wa^c?XCT57kLaV*}5_lUBjl!jx078Ojuicsy^8z*g@Hr=o;
z`hlBIYS?y99|^#>AQ}B#dge{EdW_AKxcRB0L47?c*yrRqqmL4Hq9QRVECfkE9$~M9
zP`puUXL~@TzLyFXFv9JAx6WOUsy+9dfoO^2WQl4Ot>iY<9H+In??PK#PhHJq$R5B>
zvbVh`0g1DY7Jk?wMP(unz+;Cq;1dcD_IvzLdN|1M;qObLj4IUr$!mfylSMSS{UM`u
zf>4Q499mhL#aEfyzRATG#3djGO@cG1QsL!ar7<5bWeP8n;_Dy8%gfvTQM^nqIRsw*
ztM@+zFBUWgUd~}Khs296YFwd2?5Z-S4RUbhItq`TqV_FCX?}EXRfbj_(t&&FZ#g1U
zer1pHUYYWt*>dbPx%B&FW~%fRtKuATPb&W|Vih9X?i3%%5W3a7!20|_J9BWT%^lC!
z+za`m>|MXzRi4mQt8K4cg|6feq+Yt+=YgnunR*kDD2j^)M=RMwh>E_R6%FR5^XHG$
z7}IMk8TRCZnlD$>Fj8@;m`OQY+H???&Voyy{#2;p4H#98y9XO83qtYfPWW`2bMrBW
zpoic0It)E{*UG`Cm3ap+YUf>#a1r^zyqXZQwu(v_QVvc007w;<a#LHDSIcvF)d+my
zya@z_V1{_$gK-B6#HMcru%khk<OfM}vhx#4!F4ViPhny`(eH6pf5la|^@QW9gWz}%
zaIE@7aaG#h|GRKJ73tEWg2=lc9r3?`<AFe&HVFW3_*)MEUhM<0vdjIWqF(G=wI6Uj
zS*X>LkNpqXcj0%63hMh0yInh%NRI-|uI#j_rxUx~A4^kd65h$+Ros)LJT3uheo_^8
z9rltcgCZ%DzwWE)GDHAn^4EPTU4{yxO#ZqLQs(?SsBPf<F!2i4m!{(tDtIjM3Nyq2
zvBvh#*;$ANr>KAh6^Oq&pcAv8C)zJlK?@pi$qic2hxT9hKaN^h&g>wjbkxFQ{7kFu
za7Jw(K5F5&)IU_z!f{f5=%|G{Uo9^JdTQVNEkKsuElq6~L5iWOq85lSsj9u1)L-v>
zM9SeztP%82LK+EOkf0-!Psdit^+nuKtjWzcSm4`*zmzIXTS*Rq&9hFKT(1QhqqZIx
zi36~ARE0GZ$^~rxrtmX#MqI-Mo`S8S!wl2b_lRpaMQY^6HEj8-uq&9#iEGFgJFn*z
zI^s7!Fs^|Re6@uqmPbxpgA`*|`Ed;|C|Ozuk#GTK&$tF9cxe}5;l(wq0I2_XTm!jd
zr2A}KgA~Ymv`1XS0@_q@4bKY31UL8)6>9DTHQ}u+H<zWuz|!$oCR_7_H+cBbJGd94
z)x*zr@IzSkq44vz;AfoRr(fU7`l}@Jp^%6_4qW&s`m=|kEkYtzQR9{z6dfG<Aon_r
zO~*dGs$TgY>=mEG+u0q+9<dL7d34CQ2Zc;O?%}l$geH2#J*daTJ#2RFE6#Z+kph0)
z!*vJI{uBVb5wkUi_LW|Po?}Fin45ZXflzvG^xX>10s7H*8;A`cu4K3ZDn=);?OWd~
zHs@;<5%HV{**65iR?%d7JPh$~q6UjfLVB_R5nJ9zT7HfE%=%wcTm)`7NXcnH)GDGv
zCFRCNoZw4b6&G=DfHn%H4K=?*#YKo~%e`2wDKR|(B)h$S7w4wC$cc-P?Oze-G_SUW
zPof8jix^6IgW_LV9LoqLA6%((60=al%*I0~_VD5%Halz33F+tQc!*U8GQ=I=Yru!O
z4B^d3@b!O<AI|r%_WWOSuy!y%{0Prfh990mmWasuhhr!D^Y&r*As~-3aTAip?tr+7
z*U<$MH_;->IVW!7C4Q&F54^aEKS&LUi&0ux;wCN-B1y+h+~GI0Al;B3H!-_sL&Qzo
zt{PHyfS3Wp71hwLPY}uvTk0Ia#ZcnTDs|_oZm2JD6Ozx<i}*Op@9;=POGJG5ffM_w
zo-=YHCme5_K1~17xQQ2WLLUaIzu{31KY6%{`SBR(_zB{+0<7nWpXeEn@gqian07DY
zQBM5C#|koOxF|+x=PD0jl+$^1Q2azchILT<#4aowuTTY0fJ-7M-h(Wh7xDys71{Xd
zK|47?@CCLGsb3Gu2%ep<=@N5E5OHD6SB7;~qNyOxE-xN~nJOYWq>hKlJ_>${d~s2z
z<^M@fX<BkQ$ctjolyDiGHurV;r7fHpJS7%-lijbbcz`1;-L-vUmRvN`h10tmWrqVm
z{0ArLRV;$={jlkaCsDS1zn}rx;*zUn7nRT841w8;8wAhi#8;8_erA7BQo4B?jN}-W
z9mW7Vj9eOfRq$Up-|sAWM`Q=i^&AU<BsXFq49ST)&d#3=Z#4-C!eCr7mwAH;4<=LO
zT_fTJw*`xr%3$JRHZW+yj%q}3&m!j|mouG<QFN&B__r9q2j29R`?OiXK)EL5a)l%l
zW?<=&7clady?NvAzG{HX`$T%l==nqT!}8N#H-=lLaa)qW`oPZAES4QG3$8h}ieB2_
z&ms$t!^}s{V8^-tj);tZiOH6OI?FZoZIW7fV`jxTQ;oTbHgn=b4&5H8k|x+v=tC3k
zXj*snzzt%rXY$+2rA<P>I9SfNzSo0_OF8vo4abFe6HEPgDOrEZByHDRxd9w1y!9A7
zT%3p@etB0c@NO*p#`HT4^LFY=xWS0tZ0H$w)scS0L5YyxC%h@-_gjS%s2b;;bA3{%
z37S>&?Q*Vf^{9(LXFny9mU=^8NE~pbLj};S6!oq4$J!D(@C~o6J;B@JP+K(Ym#~8-
zYfxMTSF_o1liKW%?&aRe5@%C_2%4Xx+&p?Q%&!>?yBuu3Id83JJeY}6TN$>_v($#$
z(u0=0hyS2b_S}VH#gCnb4tjGMZ@O&!cRROy(<Q!JufKFW7H%}}8X4<6xk{FMfG^Rl
zQ#m!s&doXO+}v8K&C?43g?TH|LuMmK3a*rrMEc?vKj^p)h+&^&ZGv7oe)^!Y#)cEI
z(|L?G_a)WJdQRhgGPzQn@opqG4tL;gZuQu`X>wG%^XTtgAp4egUUI4TdC^EdjR3g@
zR1`TU=t?F>v`uodZyjHzH1cQCI(c*BWbGDCx!=ic$+x^q!B0M%tkrJdOYN4)+E3o#
z$6Ng0GFjX59)(-D(sIk2{NF6^GNhlr#+Mu3rnz_4N>M9CZ+k^i?VVQ2@AMy5%D2oz
z>bFXL4#@v>g;!sDXR9<r3pAy@^O4*)nYtACGrE<e@tdqo+bBwiiBpr@=UewKN9s<%
z1R-{4aPgea8Uf>+t~&l!Xb&}4XbbnsO~m%kIKaC{OJ3+ztS$~5z9#3XsM$MRGym{4
zNiaaoEl5&2uP!b)d`)s@QuD=h&BDXi<X#|ZTIrfahp%~rs`-<2%_9z9le5IM`Tcaw
zUWcz)tZK^5@@htZ2cErE&A$O>RkQcu+a#AVy-N;pRrAQh*E~wq6#GZjJnHZ@`%ts`
z7FDay;cFc&wMM8~M<2e{F;a^Is7sCFW9EF+Nbhs@)$vz*s7YH$V#L*~_rt5Sx!=Wf
z!P{(DmnmTyx2BgMN_TP);{t9Kix0iCbo$u1c_*qIS!&;UWQ;q&lqT;GQM#TMhZR)M
zienrUE4TBXD8ZG<4x)rv^pFScQEw=_GbVSh6427!UDEa>e5_mK5kh=!K{)1$l;pEm
zJ7nzPaQ@&Rro#cP+55XZeHfF*w#U}<cdzrO*X7{d1QD^s#&4>bBuxj{R@lz9WbUns
z>3n&onkB3tN<-9k$u+0!DsSx0MAecn-jb&=7I{G`PNU+W#zAY`>j0it_<_^4Pqosv
zAS+KLpWPtR$eCZE+IpUtA?Kenfx}R`iENZ(bbpcMD*-w!lOzKO{a8bs$G)V3Jp8>{
z+e#`wshz&9>r}CR*iuWU>^lJf5v#Y=ONm#Jr`~V-z)9}y>UJNeiQLmpz+K&ssm`FP
zQ%Fh$&)M-52+UEyl0nV6f)?0Yz_Y|)<|s!hF^<T4>sRaKLyl@bB(mHZGYN!E;plq>
zFe3BX5cwcEX|h%x+wmv31IMsy>ZnmJk3xva-Ry~X=q;5Ji-c0)Lh7sQvUxxx{|Eb4
z?M}Q|I!H)|hV_cqeNDZ=&BBv8wLPBJ+6Jq24mm#3_Y60eWOIDzW=*}GP!;jVsLxoq
zrJ9ghFY_A_OaZbJ*EG~D6@%cqs~DbDQ{VPlT0f%7>r_flEDm}cM~@gDv8L`qXO3XX
zRC(JBa|jn0u4dhs1Xy1obe56BEU)|cizxC3s^ItxE-$Y+(!tP{QN=c4i@K0i0O6eL
zwJ8&$O-3n|Xke;*kU@o`VtIHRiYEG9g;A|P1wt=M1(nN`1Zgrz5=BWP^32xdW$Tjl
zxE$z9YD!<-$3GzjX3O{=>E^5_)B*G_l|El04dhjyv6PSQ?&E(!HN&cWLYT{}e1e-3
zs*j8%29W3NYNg6mrX+GnNW(daUv5^ku|!QEn+|4_S1Lnt%7hoJB{EK@pZc!y9gViC
zCl!yjhD~x7bP9wkpCE`zL2nu_#}d6b3H#6_Uc%Oi5e@5<0yKy;bq$UM<V+gggwMvz
zURu%-^TSdzOed)Or7H3Uo*mm=Ud1|@M3Hm<9vPh)5s5u8g9;~+x@8Fc5=IS%(|lkl
zu5iy}k;h5<l^<}@z5~_~uIcc~%1@!}%Fk&|3O5xAHkOpr5F?$TJ}RHm?V?ku#%!O5
zD;6nYcz%M2g&~9XItzi00D-Ihj-Y3==v`J!-RlyaM`&|(+9Uf7Vzg*Cr7>&X5E-3W
z<f>m}@-mA)^B#D2H5NVL{aWo+YxRB&z)GOz>)x+A@7FHxSA+Mf&ikc~`<O-dc)!}c
zXIH6TqjZ}1f%jmlcz4aBg!k)t@7FB<7vZTqo9_LpP-Il}Gw;_r@7b;V0&9zMD5^t2
zeTf2D7He%%YF{#j`pz+&V0Gt+cI%myr$7ctRvx^KIf;3A>v(xfC)7bO^A~y1zGO~+
z%ATYpg|2H04}-3$RO^AR0HJsux_Uu6J<xR~3q2oQe<;YHt3no;8FXE&ekpW)-+SPr
z>vLJfS@V2!o$fvJ(RH%-%SYE`-Y*|r>%I4UbiL;N^3nAN^-H1a_uc~^UGI3me006(
z|MF0>+WY0BYq|H!N7t+TIsjcsh!{doqszN(@>T%+1a+ONouDcrt_@edC4s%OMZVq0
zH@Vxql^?>k?r)^hN_o@`KRJu#+flNjd|tlEg%!>p<=X<j$<@7&stVHH0=~7)cj~3!
zE*Q<ZL+ImA;vrojf8NSZ|G5;bxc@F?|1M=~<j?!^r=L6+BY)cYDeG5sSEIMzBu989
z;$?<nq?worR|Us$|64S86@eYsM)`A1j#f<u1);2LTSk=#f0J!*=&x7Hm$_9)9^b#Y
zh;holUSiP9kmOGDBzY}n4d<m$D&*-dlt_dE?uL*xAqO+bhCyaZFAp18cw~7bIk3Kr
zS<k3=o4EBt@Ok=?+faXK$eCHgel^%mNrb2c8G)XdRgz~WRhgC?O@Fe;WaWCb<jaZ%
zClQ1#DUL+58o?=(wE;H<Cy}n_CN7%XRb3?Mv0jK_4o-;;tPW0+;SAaoqwNN1yQ!;4
zBJE}OkF=fgwM+pFFOK#Su#%E;N;sFHE!;uYCQ|SekwH|JnYwt9#u)^450H0oF_LL<
zfAxi#^|JQTa0XSv9SF-yRnn)Xt%V%;Wt@2wM>_dZ!BSvD&3iJQdKnK<GV^9}CS_Vb
zwzUemn8XM-R%1FQgL1B$3&pNsD7&%q32aiClI4!3NZq#;+Pv)ugGE%5Xdq&AE=%8v
zQs&)zWSs*IV69<eCm)xttfEhv^QB2@YL!KA;pP^cRb>4Ib+e8oSIQ<i4YIKESPnSd
zdMb6&$x>v0x)RDL`Efhf72rmY`7>y(Z~uT~HEZY3m`?EvR&rn}CBYurOO+*)wSI&v
zuHsHW=2wtZuoJ=vpA)Q^uUo%WxDa^MsX-b+T~5H0i{%-G2(A#|Jreo_HcGi8u`LQ^
zE#4<DF{ayAX?+8NYVrUP-Q*$IQ=OyQy5!=xYxA_Ef#`_QqnK{7p}!4o<x@-kQM4GX
zDx{KMO*coVUW5$z-Y(BPEjFSvlJIC0W$ra2q3l9TUSFHGi<l5T5D|Vd-C?IVt0<*#
zTx6*C^8ZWQyTC_PoqPY8kU*l~4vHGB)^Hq^XvO4+l@!#B1lS{!f>kTEqVz<m$16&L
zsGyOVXr|*RZMD@NTRlg5db6!<DfNPwa0__BfH%AnP;qY}7x4%ImAv2IT6-=*wC8<4
z|39A(nVGfMUYBP*xAm-NJ&$weBVz6}D;mtI&rVB<wbkn`o;srAJR@R8uWS&MuL6_G
zE)Y&lA@J3(W&D3(hx5JX_}szg68?X(!?_rf#IWa8zQdV}VPW`6=SRcofl_qdA#0q$
z=WW+YCB6&)GVKGvo&3j4FnqQ1qoc5+J1vLtcZchIqs>6~*t#$(;+P%)S3v2BZJ_j+
z?S5Q<JVpZwu)tdb)bl&?J=kT?_IaL3L_qBcn$4IlH$7v!^NS_U*fk04IP2hijNrT;
z=NE0x*mjiImgN-fa4v19YtM8|uU%Ml45D2EgR=aJ4xcp%SOWf&>96N2`#S_{w)*pO
z{h^T3-;^)(*L`<p9WwKjyihj=4*WT<$ADA}-d~=9t7h6W&AD*U*D4A#KpH%u$A1|#
z5WN^6@aOwIY;XmV^9(I{-uE~4fnpbq-u^@8rDh9;vh%w19@n+adjWO;hb8>a;Dc~u
z*_Yr%`z;Sq6I;}<W!~rSBB9tkX2&zZ6QP4i{rEpYVa+vdjr>RkF>PLE+?jflsW-V#
zy&Z_bJpLly!%Gu{zhkyLiI?;k=;8GYS`L5K`B590z@3&S`I|$!0N+T{mWOg7fGd6!
zOD`~-oo3p!i-TK4iBVG});3x9_23f^3t0T)+_YBAv0NNN;((Ze__#IUZj9~Sy9P}+
z8lO`FPnc_JTNy-3Y-8{2KGv`@-p5q7q6`TXB68z)H@P5uzuKy~qGV=0?C}=E9+@G~
zD4S5?BJlLwskCCw9ksv=sOc}pdrUjM#&Mbp?W#?+bK~O%&(Oo4K3J-Zq5~lk9#b=1
zr(~Sm0sV|)1jEf+Z3zs%Upuwo?H@l=SWr!qu%ElaZPXSNR`RKTh-9LSg}h5xZnfI1
zGVv=9sCynLr_$C;>6KV$t9!kI_pOMZZmOP6p+*dZXO(y(h|!{Vw(A`n^VL|HsWCe|
z-Md5mz$VSpoT_}Ad?_dvY}}I;1>%{l?9Xui-M6)e#Y$nA2GFTTZDm%N^B}|<u2{z9
z_FppR7pV)&0cF`aNo+{*6(zA6j+vZ<932SUUshkDzheu$Z*0gPSzD6=pEY8{P}uP8
zk_tdgqt-uf+=sIEH0wKyJVkgs7FaHYK4_5`q}%->j?qNV!b>aeP%EgcDw(P-RnOb*
zzuu$s>TEqLeY&yY>YOxJ4kC9i&gvJ^p*rb5nta=RG83jWTFD8CXY!;we_rA~d4c_h
z!L!pzoGc)-94+TEoyg*HUKYZg2Z-4d5NgX!*OqhK_F$mW+-oFVedu$Mlcq1hr+-n-
z3(&EqpeP2CvZmWftl){8MqDQS?0^n%D;bR^lgSb{eZeU)lQHrVd=CZDCm~z?JBF-u
zPGYQz7Tc2EWAJ5ghpv#$MJi`^%{JVKZzDk!DilmYaABa)GX4xj!Ky;Rs^WWOyEFLT
zI-SAibUB01-Y(_pb-f+`U@z3p>l^#I>DZxI1oyZ#yBZzdz}^yNgL+PxGx$U|UBqE|
zU57jp8!5!AmCOM{48|6P6`s07TF1J2h`fu*qG>Dz3<<LgtluI7x2#qG{x}Jr`!n8}
zjVSl)`6hfY+8H;I<YQJrD+T`dbgyL|1T-m9V=2>_d-wk!GdA%`cD=<qEY)xyS&<)f
z)H2;Wtt%gGvw`j}(asebX`=(Z`ItUgLjBf1XW=5lIYe7s{8nA@1lO6rYoy!0X{75s
zx|c7#BUQuG6J~Ak?Nh>^*S0P)niG+KSUI-Pv2-F_3w{XRNgWKO9}Q39w@w8o$C8hl
zht>^a$vZleKc6~c8qxHS{@l~k#wt2fvsw^#)ehiPdxReS4pUTENO6)IWE~A2#cH-;
z4QUMMRy@j_?pZK-qu1vEg90yV4w3*6&!!*}{~Wr;I~!75WFP>e|F@uVP1Bn#z%uw*
z87B6Z;Hf%tQ}<f10h|Jj7SNXPsef*AQMiXs??{$i<W?WNs0w+*n7}YJ74v>>bm5@5
zOHJj9iJC!eR@|V~HZ?``qMglupc>cz-!X&WN)$h_i3N;2k7a38%{<F9lIi|nrpXL!
z?l9d*sxd=5(*@=|S%4pS6Od>XMh0Uv6##(%mN(XF(}?XaulN9pVSdF2AA;Eq^e}G)
z`#ntXC=-^$s?JVCohdMooc;@wJ>@O~SEY?e&k!56)g_3X!Tr1m%*Um<HU{IJsUHA$
zUNEv^F9tsFj+Mj2ruQ4TPC`MTy!q$z)9~xc?NTF*9&bVuc{{KlX7(oj%pIyGzD!rc
zfMBMw_Z-y(`EmnRyOkl5fl^ns?=A8>xPNTghwiHw6`2bu$>~E`ejqo6@8S}0mS0O>
zS^D=r1)W5U+chO?cWgNr4(fYYi4;Gz!yEZ_4(AP?94*C2BCO>QzIo+5_e=SPUgsUC
zA4<$@`KkBmTl~HeQ55{{=6Al(^ZWPlSMi=x{rip5CU`^_^Q!*c=B5X-qg(0R`72&9
z?w^k^<i{m%xC^68m_O%%m(u$mnw@~&_ioYe<+<Ni>9=C^1>^a?e(%nWcY=Pe&HWyw
z-+$nDOhK17!`zPy_TJ^r;P0`EyP?NTUe9%tmzv)7%kUoZ{MVUb`iy@)5UbB0-{5=A
z8rK=OCU(`1a(^SU;o0#eJo_=vyypQ|Ry$r#<V3%X<x%+2AIcuf=U;-)zwzmRpg&uK
zlJ5kc=c{l$CR6_!{kexfdhss(=*0}{yBLi9|1zfbrG9hp)=9x<Rq*)$>+L_qAH6#)
zD4fElUyXS;b3TyEUxcM+ba2fH$Cv8f=Ecic3izF>Cs#TPpH2O&O^f3!T#2VhB-!Tu
zc?(m6JLjF}9GG{W<2?hc_c^~IpOns(>QcsXlxJO{mFl*-Waq9<l#scD=(8@gmQz2v
zTg8!-H|C%8b)M;qd`xDjykYvucGG8S@jb}gJ%C1Y;l@65VMbn;Zoq!Ubhg9TtiJ*J
zy-AF9`-dXq)*<1%iC7k|{4N|XD&*Z%H~Bdm&q(rR{Hc$23EbwUPJ8R`sNHB6gS;nS
zv)0=bu$5u#NP1yoQ~WJ>+bxr@s#J_-w7TD=ZS7}#!turie&~Fyr#ahao>}1EWfr)7
znMPNK%{Yj}7rAt4)1P<+M>qbW3VUyZu5dTL@>fo(9FE-OT_`Mv0ZnH}=r1ynte11u
zRBsSZ#M(bGtbI&LEcMuLsS~+<6MxH{788~`PTWwy$h<FR6EX^aXyO7QBd?Gcsm+KO
zv3!n$286s;mQLa`ZQkLK1{K&l1d%1y+)Tr&3SyBGq1d|xn$m@!TA50}ZQhiDL4#7D
zSEh03x`AfPe6&7|tcTWZtd$tr$vicP$h)6U{R0x1J^6cac(V6GMs}5maOhsO#7@m;
zPR{-jB{_y_tzzv2UBv=OJca0r#>W<f$W~g=bTo%MTI!GfmRaf-U$M};je5u@?-V$T
zmU?2D5o2Z*v^Y-cKD1n>a+z6|tL2N0d6qF=W=487o2cAa+NBYvFkZT&8i}Wpc)-4k
z(qz_jl6IcF8e|O+TCxzq%yO-q$6JcA7^~qziPN$`BEc+IuF6!Rp6Eu|6|ofNQ-ZHn
zu&b!AeBbURiU_-kvXm;Z;FbK*KcSEI&Ru*Lc2({ZSA7|c3Kkzj27Mcs7EO3{E|sBH
z6Fgt)p<2zf7Oi=UyvR5k5h6Q#f1fF5&QX_?$)L*2qucotF)Y0+R{1VwL9M7qQ!A`q
z7BWL`DF6f?JGassJ!8Wov=UBPvGn|KGj-kc(GwqKCG)f;M#aIe44nCM>}@>WD`qy%
z!UaZa%WL2u8lW%e`DGBO)>$Z@I~P5oiw^8PPzBi*c>STM%h*pl+9WNr@*NB7sy`TP
z!A^^pK-y9W6XYsprUk5d*&K2!##UH{L6!OvzY|Gp_nRP89ul36u~>}>p}iB@r51@+
zS^PnU@CJB=ATQ$?b#&=t77CA1RsV=zByIrfx-{SpXBF|=Z~^jGj4Gb>XI_98R5^(j
zJsDMe2TeGMS@y?n9^+rB9~q^`aAENQxJ4bepE4)MDrc)9b7!W=o<`>_iuXGPDmw{h
zd1d%-iOCeQJ<RN2?ln6ayqGct)<{CZqVU5^$4%aA6i6U_7W`A#refj54zQzm<DWE}
zj8Z8CusZ`)6i76(L#4QO@xvqwF^(hKdOI_S5K9xaNCKyKl;F&4AOOwX<qg_qi|5UM
zhRkSGc~n)>td;kZpyb)$rIEo)BXciZ7gV`1cxj|JB`CSiyrdPSn_BZmj;@=vF{7{A
zY^B_@MxF^3*zJO~!}SY3>~f%?xjKn&P$C(XPZn~rSpY3bsY`@m${A<~(;w!wAScVV
zUcAVFx@n0v0&2vw^j=#AWVchD_FA^^nYU(l*==RsvO}Jaaa3p;Y@@Pvh&}ctdBo1a
zfCr(nh};6QI|Mv4vHRP_(}TT`Gs5RCyW>D&tmAd3a)H?@@HWWAd^W0W2&Iirn+hg<
z^yzf$aw&a{EN$AT`3v-_^wqJ6_ngFa6d6GdV2%?A^TwS)ip=CQuyPi5jz$O@>KCCC
zr<W<d@EeJ=4`345Kg*eHQvn1H#4`Ap!RovoG=(n4!(nfkDheuDBu|bl&kR}slB#hH
zlxR@ac4M*HvX<@{PRr%e%6}~ylgzzPzfM>yin9y_-#S=~|K9<h@t*5M<9vi#RzFv@
zVfYV&;(w{8-VHnvKk^<?z0>mQ*?wh7g`hZDvecQ&zGJwgN&D~_mJ#9ayfrkjjUVh=
z%u`<O#(~o88^);pXm;P?rbqy!Gs#v4N+|gf{|3HHn<wrpz8oY#Fp#e!aM}EDv%r=<
zdcuF_Rv-iPZEXhax~Rcw;NM~yzX5okg_x5SUj8R$;$Y^OvYoYM6;9$`K@uTGGp*<!
z22|%&!8Oo<h<10K;7kS{0si~g7I)Tuk4^pSROYIFEiN)=A{tCIx|+RcmTgq0YRluM
z0tx7#E3^0jlnAaF{&(og-|MYn|9ASZge~gPYgv*r6MR?=K_DW^e9GCA&m@6`$jDM(
zjw!C%KT}+j0j(DB&v*d&cWWK8@?7iQOn2T-c_v<Itn?-RngDN1ay)2NbqtH@Fnien
zA%8Jnbp9w$a;~IfQf%LY^XC#a7lL#Oy_pcF6cbaGowxk6=gy-QoV8DpYH_sO?+AJF
zhC%KNEJnpbn*%&fUJ!^|f0o^RCU}>2Eyem_FwM$Y3sC<xa}lM$d+G(PX;8R?!T>)X
zq1>OD`~6e>p385EunG<2Tr&`<`<hZl4YQMori+GX;EG<Cn2N%X+25fFa0pYz8M02*
z<9+p^bxmFVsZ?gaEh77ueN?lNz)7mv<kcGT91OasE1a0W)p#<4w)2%)d|+6A*}z5P
z%jly`I+rV*tF|Xr^DcSQ5GTdn4kk1qJ!E){8w!Rx<xlP#Ju`sWovgg~AI~%IpAm{C
zgRRvfE{m&t5ihTYjWxl~En72!Im6tAeE7Lp6wM)Fz`IWut%FcqEL4_}tPxL?2=dGI
zm;ksf86Nyad8I*FathuNti9Kmn)laL{CS(?Mg9U<koO2bwex=W1N(W1XFq=se2xr0
zZx24#2K8PJKL1L&->E-c{K>*whEf~vT^C(-`E4TJ^()=v#Bvk!y<>cssX(0rn8~cl
z2+1u<`v!lPK<*R#y@CMk1+D_WSDfs|*AgGzRB?9^&_r%o7nU#0qet$^+5UMzwE3e<
zZ-+4`)8*P(!@n4AUboHr^hkpl{Gpc><I4#+Zz`$HrTG?vdAgTp`!n5@=Xck#cGj>j
z_NF~=pWYPQzChjN;@X>Dj9iFZSZ%yvl>FoT%#Dun6k*^_s7rmbg$$<Vx)BjHocr3q
zZH@*84vXq8$4}@6_v2d*idL@Bg`#Na#c0j08>a=Ah{lwf3q+ZF9QG2?aK@%v91D3j
z!by&}b0K9qP&5eXT@9_7+Z;P(yo-1AlRYK3fA?oUZ23z5wWaR6^46#3qnStQp#TSm
zTP<y&EW%-_js)>a#<mmX5ivTp!B`H4@BeN-d_UfS*eWV)9gi<w6U<^+xfxGh&uc+)
z*$+Q4_d7V>-0E$62!cs=*qNxUL#O20Dht}O^SYO}?X4Qks}e8kj(&cHVN}fkgV7y2
zwC}q<gwRWW+~nEmwdD8YBqsABZ)|%cJ972rM<~w69-{}0=fX<yasOdzR)Eo6QM_+C
zzU}a*LZW@Jjrtcj3s<{IGB?XbDsVBzznBd>NpWRnBtc~IKC%2auPLi-+d3f6@*}t7
z#M;Jid^2e(PIm6xp#5_CjNgUW-z;2<Q_RnaW7FGZ@UAYEZlsa1sFV-2m9ALPavi@o
z#=!3BEL?(JYL~O{mnw@s$)tJ<G+`WuDd1`^iFV^%p=kRC=JU%*Dr@f|CsP}-0nlCE
ziEj$=nBy5Tko|HhkCV?)p}MUb$15UwuZ+JtAXeJumiD-%+hapJW2Gxy=gI9=D&w<S
z5BNNdr?mO{`|G=QE<<sZ&*|%3Pl>u-Z+m^in<sDRUs&*_@67#A9=yHo?RDJ)fS<n5
zLl;*;qLeG<@a;NKOq+zyOu^M~)5Z5bfUb_x&6rziDRK@oPe{x97{6fj#Xq5WekxmG
zq`4QO`2kysy40^N*xqwme@y#42{jFl$YrwkHYc%~Q@BWc8L0f+>+-C3AI|_UHna_Z
z0Iz4|S*$U%Zyd%9<<qTSrJYe=h-0n+X9gVY8><75bjoK}6$P32MxeV90Cleai1Cl4
zoU{$7%~pVFvDA6|!?HTI_d`2P&*}R#vo}YF-O?4_Y17ET__SGb9H}Xve38@A#)K>)
z43DLsZl<&@xzRoFKDBR;Jk@ek(-=x5*uR^Br_zE@taL|R>X&LLx>!>d!r=V-xZZ5v
zG%PlBM>5^YkK~JPsa`b@NVcdCX0)TKF8Ry5Y~3nbAppaUYF-B;^iDAS9jAd`lrsGt
z&ceSN993L}`|hWKC(A&O+Sb26%=c)!R}o2%IB;ysdl6^i%XQ@M8JmFNwQJqtyFYX8
zn#hVqYSuXEaavkuVft6R7HRW~Bk>KPnva}&4g#i6iaoTf!j+tdj!VqOHROmq0Pkq`
zel`+?A=;l+JT|ea@z_Y^|F~Rir@*;;hT4vQ7^-i0@0|4cDCPDXzIs*SO*d^Q8P$f1
zC5i%>yl)<DD`x)DD-GOg`HAbN0bh_9ebm#g`cLd;G~V&}>G<3DR=qa$v=B0&-v~|=
z47L|pQM$rE6|AgYTbF9-Q$qwa7RGO?lu;#1`;ljWOo9IyYKU=#?|#I7JPloO(JH>G
zur+-Xo%w&_tzbT{w>5tnl15VS`Ua<N-J2&*z*iWmjL)FX+i!H22KC;4W4-_OI_D0B
z=|~WEq4<MOWmq`$J$*QJOPqy(<v!tq%nHdCAxi+K<S$k1twp27%V1@mm3gc7vVD_<
zHa|U!$^~4lqa#tLlQ2<?7Je#%{3u6|Zu^D`5hVxs$)^n_8-iR3Q9)`3KShPm85pUe
z03+c~qDoUVRfGI8f}DGuAh0f=GA<6ZQCq-YVOUXBhe0So&PnLjcXyp#h>&5zMimcM
z#;iiHIG3W4=NIdoY64{$ea5&3S>ja$Hl2Gvz^Zyf+9m&bz0aPJ8i*%6k-W<&Xf=%A
zJ5C675Th__Gk%X*o0vXW8~;)yVX%%|MG;gZ&b`ZEbp8E<K^E;Z-d<<0o_IgvmKaR%
z^z5x~_zc$gKTO)Wo4huxl}Yi8Z>$$SE{oyd{o*RX5KBHS5P7>9VqLOpR|a&JLBW6N
z%0G%`)nBB!hvPz*5!?NX+t41Vd>#cU6yF_k?mmv*7|^YU?rafFS2PaH(qdgj2&0q+
zGpVq07Xq-(abJWVG~7D4dTr$P-3pxNJcP01{4$iEC53*}c4GG%0Q7E8(zt=3xt&lw
za>o4pyVwKuvGi?k*?H3tK=1DAT&(qVohXM3aEiK`4NiIw(_pAdCDt2o5PuV8b{>g0
z8;?P=xDS27S-3P0Ym9beFb7hxM4#iyuv(#K3|Ex)cZWp{Ju(f{st?Ozr7N-`r>olV
z|92p@$Ea^aj`QSBMDGglcqeGB)bs&b?>x;&@h%wc3a@CY*2^&T@8t;fl7K`Z*k(<i
z1l9Vm<m+`UW5I?S1Sv>h>e$YR>Qk4aZQ@lSMj5Tav2DiaXlh{i%{gTp!JsV0tUQA!
z*4n1T_Id}S?J$dxrW5-lWdwGV{YV)~<Ym7Qz~1D-JK1R23bqa`BS$;crQ+(oj<c{u
zyekOcZoUUfLG_yqSiQLE;yFM5XKKMMdu5Z&sRb?ao$;?Q6jCSRevp<z{?+^yp62t-
z?z?3VFnrt}5Ipw|6y^O}9v-hU`dRbrlHRK1i%kcnZvw0QP|fPuAJ*)05{s}qxDDjH
zofL{y%K6K=Tk)OU&>sIk`J5+=g*FPI+s+_4ax=3pKwNPPicU>7v7EmCxJV%&5-0I4
z<9J*m#D9iw8vm|$B;JbHm0km~H%)3;b?cFC!z#|oN_x8wWIi-ZVC2T)=8;v6JCfTC
zuPW_v5{EDv4j;$Iw}zk<hSkq)=pZm(3mkJ|r~f~JeImKi7-LJfJBbYxbw3~QnYx-y
z2<`t-pKn!@V%5~@UgUj<S;hao&Ij4s{*BMK*ZB|Ij|ceRegSubbwz$}<bvRc)GE&e
z3(^f>t{9Lxu5EL^-puJ5b4GVw)mRbtBh9<fo!?Ox=`)Vw&Wx^pHWb}sbmw_>AXlBl
zCtC9o?0eO#szJJTl!s6G|AsU(Fp`bW%6iWCQPKiMS=*MQNZ8y}Rok|uD5q4T;j%|w
z9)Ev;-Ye%Q%Mx9+Rh2V(a_3j-$@oT3>ZEHYv7F_^Yq$7vn63%yiS1=j4>A^?0BW6o
z==0_~ZmV+@Z!5WjAev6%H+(f=G*=senmLEyVm~0b@@`8KFS<mhsBjKr@0JNAkD5H_
zDjL-9d0<WRr>MzKqBGTTf&`RMk`?a=4IxiQK9fU7>B#O=(6!lE;0eLneC`fiC!uU4
zvJC!g3lPcDU@<w0rrpw)+_X(GB0$2iKBgAVZ3~xcf1%%SFzT}Vbe`-UAxKho8V})N
zOBE5|n#<5ZIo>siE9B`EP0b|7r#TPVW~5~|1NJsOA!)hITm5(+X}L}QF5d2^b+#tY
z7v1EoUL}ms$*XqL_qBl&rAvGtO5@3Fp3sTa$n29Bd1CP9DKThY{L;93cRy}F@PL-R
zxVHK8kkLGyy3PLSIr$skv^~DMP`Tcs{&y(m_;!tR=U%!`K$OMl9Y%8hL?1|Qz)HFi
zjNNiGX5N$CG<3ju@gy(44PG#d!P)*EAI@kDAnKBvqU|44$m^|~`A&CB-*K@zX?=4`
zR)_s>m^<_xBuKTaiLKeETG3c3Aq81Nh;4H6HLA%NFo{-K&5Oeq2aiiwoSjvaB7XMj
zd$kc&X7RR;h}hNJc^X}u#)GlxqC=u6a5_F-Tt;^huFDc-tpYR)IEB;lD&_H>&t{h>
zamP#iz>V>0_|LPE%9k-dhT?nB4ORho=>~`FtP5Y8uNlOKW;BEA3+pOT*c`Vb-qUbv
zS@q5{q!rXU4<W}J4?-<iQCPi}yDfm#xo?RZ!Y`1k+g#l-@bxZS1V;vb6*8V1&|vIt
zW;pIBXbM~8H1JDiKk=PBeKrB<;58wJl{0)`Jpv!#N|5)zLNTzJ^TXFh+BUOG*@#N9
z#JT4;G;K7EmbLUc%yD0J8+PPvQX2c4O-d=5WSztq+8A58%uSE88<i!@EUO$fR)qY2
zp#n&epiy(3$3>fdny=MsA!O&?C6Um}zJmAIBN;J3e-9ccNNq6K;<cAoLWS3jipo61
zI`94=6O1<C=d@QNYO(qhDMxtTJbN&5ud``jTJbJ6haxqdv%4cTZEpHT?YEq|U8HEj
zSd6D^e+0=6ztPZ!#r~h-aLArwo<5|ver|+Vv*v-`%ILFd>up9Wp+7GLHT&8I1$39#
zf*m?FXvj}Yo}^cFA|lim6)PNE>%HNJ`I=L`MB`bmG;})@_lb7AF89~Xl8DNUT4fm6
z)_`&CgmIy2L1G5+4f|4oLH<69*Gb<OE(Ol*B4vYO0X<LB6GNFIZtpr+svn1=<m9`#
zfTi=l`qc4JEO2o2bJ4rVhBV`J8)L*AX@J16SuzSrK+1j&8buU$g{O!Re#v|XKJ%1V
zPg1!K{b-&6(H3Xnh!agnliJo12T-9_kxjUI3%rQdoDJO=%^acWZh{ppPU}~SmNG7a
z=Zlt>U!zm_w~Om#&u0wE8A5gvLdqvVtpfk(?0QCaX=5_0L~&Ha?+wCzK%JJgw+?k1
z*ooE+?(IG}i|_mBGd+uWr=YHs1Fr*VQ`nn$nUV-<Pqbk>jKHcj+l^YY-6-+~kMsF7
zw;$1^EIqjmx`Jl>#aFhh(l%ig+XRKg&^Do+#qAGGZ*<ZRf}wD&>^6aNUuT7ZegtW-
z47L9K2K{T%^jDzw?UvrR-JhDPm+V|Dh?p5fDfVm3U<$_8bd7Z;E(09Wulz$OH5L7n
z`R3j6cgelwemO@z{%VdjbMYB2#6UUCxfP>zzK$hECI(m~{82=$qXJjH2g9s!LG_!-
z=i0glv|bz@j)C&ncwnF`)rnI2v{_rFWMQBj@-sKIqj#h9PRMEm%I!l-O3n`tuigUr
z(#Eq=v)VQn#WxOMA(Bn34GjL|&}q!D`C~Ml!#<X#b8VY*e(}eMK!^KdbET0cpEY{U
z&-rTfoSzvz$0{w>P@Nt$x5Xl3y9&%<Mu~jRrpp$1hZ@7bqFEhD$@z7Wl$@)HR*K(M
z>u(_PK*@plWC-**?IqkfIeRt{1&i6m!Y31&D88CIh3{4{M3k{@Z8BgrhKF0iYu|u9
z@VUC=wvU~Qmb7mwE=4yRWz7$$J?A5c(O>@feXGA1vX)=3^cQg0I;yaRVoSi5e<uU-
zhW<rD21@e=Jf`IgHvOgu!G4NY#VSjYImMTE10aTYM;J{;aE4;;Gtf^yTfHR<^wtyz
z*SsfWc$+hJhcuCseGaYR|L@@hHp1#VJ9)Qyi`LE`$1}5lRxn7Hi7aB|1>N(4&y_j*
zQY>8KH&7!>kIwLR=gw`Q5RMG!H-GdEhySZSjMeD;@X2C`RRKd3`qc_rwcdYi0^6^r
zBSVjFnhQxr$q}@%i*Ad=pDzz>v5HJ7L8E%>O5bPRm$4qGKVo;YB2P%sh(5!b8bvia
zbbX}#y<&hj)v7`&jg}fHSMa*@q-MP_bbb8&QR=8Rs7FOw<?iYGRZ?UarOSKLhPYH<
zG?}66W2LxhV*8SJUHdllnk`W13z6g=CG%^MHY3%hv<{!;yI$lMsDH85ZC=UhHfa`~
z7maRniP3GgV1XnuO{_9xSQ)7g(QQ^pw^?Czo8F9W(}AB)4Z2MSx(%1KPDYdhSfk&(
zW*EQNwlqoa#=lwp#<&H}l43bsnoS9s&0Rt@i7S>YPqR52dO@=ho9Lt2py$d&_e}r{
z>|^0eGS*k4*F3~5pW#2u+Uhm0xea^r^qScNP+_*rLa)ILGoCia5{@`MUWLxxa{)yp
z9!!7su#kT|73MLqkzdefUh&U|xtslxVKn|v;FP%78Z@<NtCXFY67-qt`DyUV=rgA?
zElGpqE{&w+aeg9N{)s+wtJP=rx|Q3lJ~IG)W{)8y=)t1<l1&EPpV5aDnt_t-w%_V4
zR-ai8o9XZ0n;DPy6erq#aaR5*$=t~pm4>3z)Fx#kc`4)MAsP%+8mSQJ#*+=#g*g!g
zY+GAh=_X4K65}Vsl$Hwj&6ccmQ*@D*1qc_!H;syxzHAv(`=+W`=_YU1cPx6$GK82<
zp0z@aX5JFcxZX2=g+%|>M_)0B=Om^uxcby^@+|}k%LU~#D(gA1<h^n{CXA6-+6<Ib
zf}&zHDWl%N!#H5X;Uaa~B#_Vy9u0-qe;1Sl3QCm}6xoOMFfX>Wo3;``GKCT9{4zc0
zDx76?P_#d>aNUP}#X^fO1?6w~{41lMTvEYxC|1SlC*RAikI_%ISp7swra_?fK<KOV
zldU;>i!o&y={}w|jeep~lU6_JF$cH}D==MPjdUjV_=;R*@F%cKiQf|cB*$+9{iFjk
z#{TsaXs(V7hUs-+T%__9atRtMCdK}8imYBz<^Lx@kQ^5~;WScuNsm9@V5!!>AlYe-
zD$K~!6q~bC;eCw<*IRDwK0E!dF*Z}tKaFqR)<-4Cmiq@h3zDzk_!N6jH2Gqni<mQX
z8&o3xq3e?GP*>#Uq{daa>7!~*;D=DRP9)I#x!zBl>bIT56#$($i6!+lm>xGqopG<p
z;RW=O_w82it>4Orsi~94O>E7tn}YDZPWK8cFX2>soW2|;rEn<CaBA)1ppwVnWbYe?
z6Mmc1szgA~)WR9O-~IRA-X{+P2F!$Q%y(Q}h1^&Ku^d{3zpbD{Q*BjlN9{U&@2Ksv
zAKUeT2T{`-5%9etI7^pzwx*Yq?U!&2-7*R$=TlY2!E(T6^nQ$VNT6cW{|eHYb{`n%
zkr?Lkp%cHUEYvjKO@+9Z;_BXFErx&s60Mf7U34lZKyVmo2|YFe<!Fp~QyvQB1l4Yr
z{+-H!T#V~Bp-{2J>2l+Pf^&-$Rjf$|Z44E7tDZvfu;*dq_}qAmlenIz1h;qsy(}ZI
zvn$4?z3Ds|b<5646)~2Pxv{yaNg9}&MA+hXa~^}5fORTwU<OEeqthnF4zCJBQ&dh#
zFKv#u7c+{cl)pL4UoknQM}J>eIlbNULAvyLLOglwwYZGczd3{7>Ea`9DO6Z6g!cfK
zKyPjuZ&YGr6?@IU6Si(!{4kT6;{TOj;KNtcpA^(D2TP{-b4~qBd`UX^M6pujHJ*3m
zpD<3M)omu<?;D_4Hs9~ZD>UjuUw$`)-6AjFZ!9$pOZv6t)vJhlhS?&62hO9N{fLs@
z4=ahAd<k<Ic`21RbxPQz06u(_TQvJ%c|(+LCQ=mWYvmAYK_1|CLoVqHD$Yq4^-~()
z$Fz<M?+wd@)e1+}cWrV|!;J!d9PZw@_{mL`6Ret#<{aWStbp&9R8_8yHSEPjzCP5$
z-h@2BnHRUmpDkqftybLB;dQ*NPTbTv(CW?QvGhRhOq0K7bBTI>G%N)*TDgL}pj%_1
z7u=f9XP)Y&2uG{!7d9z{zXN5J1`2t?hE|(hp2_S5%Bz$=p!=0X@k`iV`<<gGes1zb
zIT+tUgcZ5coJ8mm(4z5cCbB<*2|V?V{{!|zVXU<75a|a|;O6S0L8!yTey!zJOqa|X
z_0FRo_9Gi&w0%oINWQfY18}UgtEo#S1p!aaCna+*j2{Fhd8_Zs$bSh^afdt|YeN|$
zxqX>1B##9Jd4g-T!B0)sg&^YK0DZ6U*RpYb;B9_HSc+lGdXz~rmzd2${~%d#snC+^
zr{+|NI0GDPgBgr0*Wk6x&HD><q6Qx@4R)9##`5G+icpx#yd`i_odTV0-dAqhdcxG2
z>{ljt6@JkQbAANJ;Sedgtq9hW%WSoT2TuHLm6^;|%64VTURGI<*~&d)r4wIG0gHhE
zix}ys%vN=o{kP3;Rb!kpj(Eq3k7gNdeyd#BNR?&tTWxiZSntF~P=<U_c9BeeD^&HR
z-e(B9Aive_NW7ycW}6X)F+2>PJvZE?@H@iQ7~2B@aYA~;;3)0|i6g)rqD_|Ku%cAO
z#K)nRI(8z;jrD9@<%@VlMQUEW?I3>*4~*QZX`gc}`Hm0QNn_<o;#J~*3o$y24~Qh6
zi^RJ_k>*e5%zWLDZhe@9#}y(?sFeK2ZA7qiDjy6#%os#hzcZf;!oTM;LzoL7pSsk8
zVaboNoJ8Z#c~|)Wo!MJj)H{Jm$2K5O&~ohpC)cGOHBAeH5J%)z)-y;frmGMN#>7uh
z3sbO5D4JH&`^5^*dwzIo>x0&gl{%&_V=GOaS01bJocNCdivANXL=|;&hSDW(QD!eL
z=b($s{h?5bD400o!f6s_V#L!l#EQNza!mkgk?U;cB8`;W3;6rakfKTrQJbJ3iT{h6
zVDG<1wRPEA*QJ`m&9~a5$>Xvac*llU)E!z;<t+RzNt2txt>+g5WqdqwiLYK|`63t7
zJB#3_MS1*`Rp=jU@GY;rykbJSXt<0D8D1&Qri{iSdzJ%ZiOp^H7xqqH!7G6S!4ER)
zW0~x}ywWmc%PVg{T^J3o>~!LaFR30auUrCD-*7{px-}oqB;bJIl@*3pl0&&Ko9x3O
zFZvP=`8}9|K>h?ES5hD)<;9O!ZIyXNC_(0SJ*<YMG90p8RvG-F30oRV7gw%k(-T0o
z`KFRtF{iHh_}RG8C3mAIieniNb2bXA5TrQ=8i7!k?5b_8ZhAY%LSOZk-^ik_#0afL
zl}yu`el0yFlzbz;v@n^spvfs_Jrz2eyqkGqGQqMiJ~|D#Yfu>wldrj@9Zg$U)`Pwv
z0xiXVl?c2NX`Nlxo%@PFVih9-w}0uf5_=YM6Y4}$7ZOo=qE?l#WzdTW0#&(OgrJ2b
zsKxRif8D9k6yhtBz7A%clYnsOAdy|Z1f(>I4{k;RM*Cf8C7{V_x0`j<`u<MTx32^Y
zOBm!!z@1LZREWw-z?}UyPY%jykl5+@VsJxd4dv|_n#mew<CP!{+wRtS+WR{aUu~Lg
zO$Tw9IZ5^kA7+p6iaBPk1JVHr2<>H?h_Z)ForQuRcgE26XzDsVQoZP?@#Qlsqp8CU
zXuvVdLILgzKzQZmv;)Bgbx-iYm-Pz(I2I|mF96olF#yoM$jp12k^gz~9uSEC4gOJP
z;I)0m-3G>xQYXr}f3g!D2o=dqUC9N(5yN7mZeZXLZ7}fH&>QlJHh<v8dVh0CEP2Cz
z2Y%&$?K5z67knP<!1KqQueW3d-sLx#03v<H-6JgRGw#pb)J1f@&K-5ONi%(bWCnT|
ztAXH@Ha6HEju;)R-$h7`v(cqcq-<(ZT}N1g<fSOXJjO7@fO%k2{%}=a=E3&!H2+5O
zp(-V&<r`#k-eCBK(y&{$(dsm<_x}s;`5b<FSFw)%%PO<`#$4QGKgn*tF1c=O<x=Cn
zgmkTMc*&QaTJC+8NiJFg*@gx0o8NV2`v6{ogy<*!Y&IU|dHTFi@&d%m(G^w6m;7H5
zU&Z!oGJ@eLWx408zsPY<e-&(vN|rwb^<cE%r}rmQk8f~U6W4QIt{pwUJOBBm%D<a=
z?#<wl-a>0*WQYlFlbina-googd)IE7_SgUL{Cb7dn@2b>g`$wK&82=m;Rfvutxy&w
zjPwq@T8@BQjc`V6C{BMNmHa^&`-S%s%kQTdvV{-y{V;8!vJgaQMk!gIqLpZrkcpH^
z+N{m$A=8ao66hfrwM1~8+D9$P=pjb8$*CtUA^nNL1;t%eKJ!4raBG-J!f?l=fb_eH
z{a<DxS2K|q(X;&vb9N8;uVZGis=aVt$s)K#VQg7wrRRq$yz=V-N6VWgzp)6H@pm+y
zC~1i}enWNf6JZ%J9eay@B}`CBKC^{nmu8u*!K*wzn@_jd{f6NeTt`CxAwY=#%Z~$m
zj3r;njaN#5@<(UJi$4XGA<AH=MoBRFqphGf1C_KtEH_GVpPa~_WAv<y$p7YwzEmrb
ze`;eO@-2ReM<DVI4d=^!B)%?Em9A)d+l1+1D&&8-j;XBOkx!3Ng=NWue{{{Z%zRAh
z2f_b-Ui;s|fAlZ+2Y-a!49n}yb`LtwgMS{s&wzh}*^fROtK92-O=JE#V;-CAVIRQ8
zK>3shXYwf@3r8?^wcP$Nzy*Nsy>o3aa!c|`Z*JBEq<Pi*@q=Gv?8n<t=J-{fT*}9j
z9Dk3S05Ry$c7Gadq>U0^?p^X#{SV%^f1o6PB_!g0`_F?@ruz+kk?FoR+rK8}UBj&N
z6HjjPe*GVYdu4>foIb+g#if1GOv2&$>#-HfUinYu!`$up_*9p^so4J-%N5vB_}$+>
zu+Q%S{-<Wp&G0AfFfyABuS(<2atpD&um6z6ugs69mE*e^s`p;McOR7VhZwGC+7IeO
zf7$xK`$GN8jI_zGk6g(T>rJ`(mRNmdamo!u0^kBu$6}fPl$x{hA&@)Y%zu28BuF4W
zyrXy`v2rbiV7PxCpt0L@{}ljh9oYS6%~yB>j)>-Kk-jeAtJnQAHNesI0{b~E_|$LY
z)V}tzmAu%;UZxFrU@!Y`up(<OD^xq_Lz~y^V=r@4my}hvMU!t?IfH|7wEe?=O}p6a
zu{)e|RP)X3BnFQ<yJ+@6c!tw*6}A<|!KUEIz$jMkHhA@9ztz@z9=&T*@PPST5dH<9
z?DZsL1{lNGgDBPP3ht%6X8W8&V#X>qpsI33tYH)SUM%#!-4Y~B6M;9Y{o$qt)M05*
z7uZGFjZQC*vL~qLyf8kMW;xAyH2f=`)>pRICzXWCkA^;v)_gJ(*#hEQ?hS$(9YZox
zCo8Tvh~23nVM^S7lTZV$Fk1pm0)>rjwszPuX=^+1Bes2P=NbnaZQ)h#NG!jG<0B~E
zb6OhM%}ZZS?lE#Hxz41k>KcIBPsXZ#t%cYf;VlA;Y+nPf#P)@HxXt@c3c8yoyO)+Q
z&+c`jjWwf{{-WKhD&I_X4^Z$9_zC30=6}aLjSHU}cu8P<K#WhS(6hsYWSG3}r_BQL
zrI?LrUz67i=HV^=v2E+WO<RG<i!g3#W9@y!_el_yWjDwh;|lQOwKNt>*}h^dvRaQR
z9p$s3iRpo-l2VoLJI<=?#JOhCHKbH+Tf?jEJp<i_m9bGno+VIzdU~k7<~gj7)^aoo
z^ZDjb^Bzn`KcJ+pa$PL>I)3dndv80ypGe8Pnq6~_!Cpj6x%N=y-dGI>rQb95q8cMx
zM$eh~wy_m89aWd)n)wu#x?aeOm3)U&IX~RY7`6RNn$JhWKjKph&b_L^K!Dv>f|BZ0
zk(wUot_#@-CfZ~uvM*%OQ*WC?G=(SJT-$mz5t9jkT*sH`G8;AXTt^0zqNz$DBCB>W
zR+-dTRG-FhZ5_BcRVJh>Vwij49?K}R#ofFWtt9n#lMF&{$3i>Y&`Y|3Ja?fMEGZk~
z9Agkt|2c!uFrn*JfpwxmyH}X-Fs<3Ia1WKvIZP<1sX`52QcQWYQB<(^q;9n&e@ujf
z=DMVeeuc?#N3EzksJzNqcn$`kTaRju^#_iZ!#Czxeo@r43z!}dYuIjiLVfwfbkXS<
z-=-Wxcre2dF#cG65C#JvYQqm!iXXINC5Ioh#~L=k59&jkzM3Bdj+=%bxbTA!@B_BM
z%IP2wT6VCcKKY6@{(S7#Jg0pm8!pQZa5@Q;Q;6SM2$-6*)eJXqlau$u4TgXm;s&1q
z-W)er?G3!Q4>wS(2XRsshh5t@IdGTBr}^fRSrW>pUn$)WMp4TL5xF<pEt^-QEt}12
zm*Es!y^WW%OmCxUyQ%++WpYzfEPD^+x7KUThfO^!7xzgy1596#<KGsTx#ijq{~nD@
z`Tvf8pOYS4X!y5|hI9NI=56l$lDzG649+vezs0n*Q83#PBeyO8wi+NzJhx)|=ieJy
zDXrM=L5<vsz3N>Azs%#`FQGB+hku8}zt?obzPI?JjkBlt0#)JM_qS+K7Fo%Zw&84y
zo#qrOdKcZzM(#NCN*%DX{*2L@wiyGX$z}DG%kYp#>LJ`>sVmARrU?iW8#Ucn4UE!h
zb`xB7l(>?CCOc80{Kk^g$xpK_e>Qi)vGZnAZ)cO!KP8W_40L7YGl2QDvd_=#um9=z
zWQ+NKAKn%#NC+Qmgr$-_0&Mh&%($|0azN9E{x)MIY8IULJ1)2baC1|W%f6ldM!(po
zD>7g+yG@HK0oZaBJ=w^2V{FL?@zvf1W?UFs?6@{*Wiw<u=r%5q<dN;5=4sNUGwZ*^
z0CXd!7SSypw1+os_D{>$<-7wyFaK)UOpHE2JKzlGCS?8dYYbMH`6c(@k^OX)`i0Fm
zyy)L+76mWxiJ@fuQD?8HJEOcRl6=vRW2y=473>-|dVffo1@~L6T}q0mDgS9ueyiD=
z!wiG+TY~a(qa)|a8-j9qOXRmdAt=8fXD2c3pBj|w`Wf{DyN6^-&hBx_59|g&vPTF!
z%scv$tlfh`WA`|KO8(PXyT_ZXgqe(mmq|LA2-GET-z1-0qAelIxYc`sYg?edj03Rr
z4!a?QZqWB%^_ro)%#+N@J}5b7)HB<DMnB8Y1N3c71xu8i@;X}guk2$lLsn_M2tQc!
z?2J;*;K)|RrDqBMHVOY7M!YLZh86LB#k)}mjCzpK2C%`GMbj4_itGH8@|gqk(L(}0
z*6$i)a1jJ!c+L&;-n^JGnHVkxpZ*Da{&?wEz-MZDKk&)2zrOIv(k1$<|AxT@!NIP3
zW_?6tvY*)Xkw53jU+kYsW_?zBU3Y!4|F^^uGL&~(@!$JU-f8_C0)hD@^3o{xOJo{Z
z0HXPSHpT=q&ODu4lBC4@DHXsN@y^4<RY50%G!qz99s`wI3-|&sEWPiSPmSMSKWsDb
zu<}mo(+?%V<ln{7G_Rk@`STt$XhENO4?5`IaMH5;gJV}Q@O}8r@{B#}3-kQLl>N`M
zp>O~4kY%3pGV{yOgXF^%rg1y}^tfKxYfjDBYaR;hH4@8#PU($Qmx0P@$^Q6@SPc_j
zJ;R3#1$$c)ISlZN!75{)6@RhMSLZ(;3y;|6`Jehc7bnWFxqEp6c>P)$%@*Dk6#g{7
z@XDZYFNKlhcK-!ttItDWgx-`p)y#5#)%?Dn@ABKMM|M9>ro2z_U(qg&{rJGZJ^U`S
znX6tEzqO1sE+6nP^<6yv2ED@VG%nKO68>W@$oFo{;+M-o4T{j2cy>97K?h5V9b1wh
z|IFwHr{(a$=67jwN#;0vAWjayo$j<0@tMF2>odj`OC5`l3Gz5&^@ye~2*tTge8)Uq
zkEN#rkFf`#4&yf0Nr2#)xDF2C(x5SRz_mW;MKR=uxp_*}Oq`X=l`j`<!#Ia9FzHf0
zE!MT3#d_ff7t(%q^!FtWYN6qNE_!0Hl^tQg;k0~x2v~OeG65-XD{Jdth)2qe6}Uh3
zP9g-;7=9IWFPi73CYGfR;}(IFsAO9dOPie%>7+Zn$P;w6_$CNyg}1zcZFCAbL^$rU
zy43M<NlVxyRkO9VA~<SY^0M%BqVvt7bD%n@bmx+(jmN|{PJg0;0zH5Pai6bv@+4Il
zy9U3WMrZLX!+)oG4fJ4KYy&!ETy8M1GB%?50~`5xZeX#kyhc_jfYMB}W_+<=d{?kV
zlh3gopVIwme6v+;f8(3|#qrI`jqlwpbaV$DWybeyg2!@n#~9&5Wds~|63-Y2nu7o!
z_?qYZ15{TNl9o5TK?7sWNYPUT$5?83EcI>U-j_&7F651sjjj0GEUph(#*iEHaaow!
zXZsG@`jF>FzWa4Le%`1Nwb&1I9DA4<?l24=k>*(>|7dxEM)1mqa@x4>;2zP&r4oDy
zi*=p<(7&q4se3lsFsX=`MdX0(be-|K;jWD~XKw2Sf+}IbNbjUO>FpAF%fM+oZh&R|
z4Z`$dIbdUimz_M@@%HDBiF3K$d+!B!TB@IaLNHFjhl@k@y`S6n@XXWwCEnu?R|DzT
zi*ZL>?`<;*POX9Ko5M|SAvPrRMxd>WK>=>EYoNS5T`$k#BD?n@h;$Kef6sp`qaVdm
zKV(gZo49;au>#-}fa(M3CvIR6qh~mYEA<IW_%Y|hB22WT4{m49SJDLWg;LX?E^;{E
zNO(S6rDjvxSvXEDv>3};!?>cBwpjzBHOpeo_$~uO13+a314Bo8o7wG{3rK-Jdm-cb
zrhH1VM4U}KO+z&AM!M9zcNz7wmJv02{@#bOevz?sOn46(w#Sk$dQE@NV&ZDA2c<#p
zKE=D5(G_rFe~Edw!1_~ha9y)GcEoBY{<EwXRjzDS){81vc2UNQ%Djlh@GRp+#qALj
zhHhox9KW+Z`C|83@R4WEI@>|H`N*wVA3I`$6AuHYXKwr1{gmxAWt*IME%^D2{HRor
z{5W>RyH5OE$~bJTUiD<z3Hm1NW1kmaUgZ5{wq%HLoJ#gQ^Uxh2t=`)eJK}>I=IP9?
zOjoKKmb<Bw3^$1-i^9=Rn@MsG>Xv^yJ)$C3LtwVK9WV}M3MbSX!@mrz3)@kJn>zWh
ziwa3qzk=~Ik63cGoFKP7c^M1^{X81qTIjtsm(($NrF-kr;R5e4h89gO*JUiyXc1<!
zuDBr5IxciJ-;U#3|HrKZ+B)&`g4hu~H#}qx8S9hVAIBa{q8%@IvJ!{ssu^Fy!uO-^
z6&8#QZQ*xFu^nh?$cd5GN#rKiMm{wn9BHj(nRS0>{H^Hx&$8i}Hjnd}$kP=xNz(WD
z%8>Ik^Pf`|-+oMls}HH-%hl+=Z;{<F(*F6tXu~UYqr&qd@wf2^U(SuS7XVUCY*bTu
zCds<dHrYL!B<s>oB|ro>Lfo-q;67rgJre({VP*{Qy*61JyJmXlJZqzFX2<<P_utnZ
z)6#t|9yrHcwdAtO4jo$&o&Dud8!-wDq;Ru8w4n9eP;2P+Ucu?cB?4p>&6ds-B${b<
zZ0J1$-3%!HrS;sstq~mB5%Znw4r8IcB*Q3i;_rfJk)6wnoR$+oCG-3-p1Y}{u(PnB
zwLj0W?)@?-8k^j5w)2m=VSA^Yova(a*KeWR>LtmSxdqUAE~}I5v=Fu6%!2YrjVd3M
zFN_+}DoAn-L^+RAr`9)o9>oP5FSHnT^ikKA&-_|6g)0F-lM#IvdbDw5C<?QrWzl})
za2B~1T<mCBd((gw1q8dp&E5*^qVPHCfg=r|CjjVcFU;t(2F{!I1LqaV?OZPVGC1$u
zADqi+^{e1~1zY4uycZy^1}u@C9T<6kYfRq*!()@ZsZesj*{Qmk&j96FpZVX?G1WYy
zhh1(?+qQZ4+$8Plq<SzCJR4bW@QjNW&^Zc|**9(rw5NKZm}Kt9Y#&Xaauj!<79!ul
zZD9LbW*c8y;2OGt!Sz<}#PWG9URNL}YQPl*1r-I;*gjtEcNtTF6|>Rg%hBWu=tDOh
z5Z(1wH2z9Kbl2N~n`x{DZoeXS#8xN%dpLx3E)@&hXv$J5GtQ;Cva3}lSei<n6Q3m3
z!bTI`;-L#xvl|YFBj#!q!N|KuKOw%zMBJL!V@K?D;s;{~HU6c_H&pXZ?1<e?{1D2X
zuzZokKi#n-K81f$md_N)UeghYuPE~V<Ho(cPgrJ1WgqOptAS>2xKAd9R5%<<X*8)(
zE}v!51{f;5P$|jX_AO_{LZ5)1Q8JRxJP@}ggO|O%2b1p>T*Px5AIdl!#w<|9O#=;5
zD%DmUew(l!oXU(oDMs7zcms4FtLX|jnK$ERFm>7a+HoovK(bqUs(2?m@vQ+<h4)6|
z+c@Ul;?137IcxT5U3x@;w`is~>#_)5{J7Ub{rw`X<Hc8tPK~q<uxynG{$-|9_XzKX
zUx~2}Gh8)d6qvjLapE@UR0cFAT@*IVrw9f#WH2qlRY!!yOe-R-7s4!HvEE0sz_Z5e
z{tUia%LL)8E}VeF7{giJ`1Z3bYdw*M`|yKTVxz*H|8K07xcrv2M#WmM2adDP1CEQA
zelqOhdzO4MEN722TL+kI`{qJ<v+UYL)FC&%@iT&(6~;p7a78~+mG-Ve*Z8~eqdvJT
z)K-_Swaj;%VZn8+5!kPL`yRs=esB0MeOvxpK;K`*7bdaegD@@seG0A2^52<g%ZC3}
z@!U;W{yV_(-=l+~KK%ETy?!y}hW|pR=tNHIU9vZc0~^=}fX@N_@88)6=r6dVhOGQ2
zT$scMd0bcqr+^J>-Shb{BiKJ9Hp_A)%kuuY`O9MLcx>hVe_oI2boy26(WWzV!>4bR
zoEM*N>Bq8+<(fg_5gz6(MhC)hUQh%NmoOY@gyC6x{aGr{@z-AX>m`QvC&6DQTmCvb
ze6fFyp%KepbM?8d!wcUwFVymaYhI{>b;SHGmO0ozNPxd@4t=(H*Uf;~8_o~!XBV<5
zqeP4MjP!neGb-&m&iiAjQzT9%rbmo6;$&ddTs^?K5sgJc#Ay0|qNaq1)#oKd<|B&y
zpHm#@D{PKpsncWWlOO&gdS$x!SNb?&OFg$?++EzCUCvescOwq!M}MP!)UAeH_BS3u
zyL$2S99L4GytRyg%%Lu$g^-}2ApSmZFJcA2<HR@UD&j1xFK8{<xdfOWWq$u7cIe(|
z$ynK5f1nu(@+{C}(IEbrDl6%U(n{oKc4rmRtMOd|I>rxGB`NVm!;~|+Zbr?N&Ku({
z#N2*3$oV(%Czig<>?hdHqG9_mX)kgP&{-^?;V*L@^{yZ!3_{bKQyYChmfYaRSBV#{
za^oMJ#eIX+pkpWYIhfuas|kPP{H&cINp<OOgnR|ti|l&KYE-5XG}e7ItF~|NOVlW-
zMzxY+WgRdx_C(CcGQdcsf_BZ#PvXg1LT3I*F^b2vjvnU!9!mnuTL$C$^yQ)0sLKO;
zG4l)b+p)~`a$9>gwT)(y=1xp}QxCZslAF0GcPQUtWj$QVO`l&}z;%Q8#-8||5@+rN
zUPyLUuZ?&0B-g~3D3a|UIM?WdYL?uv)jyf1eL~ZoA5{Tpy0NZxq~gt{XNA18DD(?W
z)tu-?%7^^XQgQR-IfaG(2}X&v`=0pnLcaj2+NV-KzpziGe*T;I9?>g(dz~)+sjVaZ
zd6+(AvYP6qCo<U$Op!yO5n<fR0AzoDo<D#YzZePix|OKeAM}tq&oG#|7x1bIs@t%s
zwK3@tm`g?suB+)`(j))h+x?tWM_<}*CJz$h#kyj~+uu!%X1pHbWvEFFx^i^{<)(61
zB>q0*wY!74zc%f@|HbiojJK7C`-g+t&4<J11`cW$II!!OTmMz<R_P&b6UmYY2=p2F
z^O=7XWd{BIA7V1H-$rJ??Pcd~%e4Qu>Z5-$kAttDV?_zRzMcDeI6AS{%~eV4rzqrG
z0)@O%3i&CY`M>Md^hOv}y}wb_&kR)cd(4y3=A8k_{wVRM=*jTU{3f1E%V`_rXIBvF
z_=hl;6Y|`q&?pI09UmPgeA4exl1zv_H`V-GzW<K@Wlg8(qr^#c-6N~Y2VUb1#vp7|
z{O5zR+UY7=+I<Of6hGbcX>I>ulZ<pA7woo)8<y+|eok8`y51>jgoVe#?Df;j=KE6b
z@D~t!_zFl{<0(fJ{goA@@jKj_Z@iu;#3WYhKGE7=l!yHTx1%UbZKC7DGW5lpUnyY0
zR!|8r_+SRcqsUsNn@;2+Z-wlyOQ+5AQh2I${{~@Z<)8P|b*Qm#5+=ZJW>ex_%&`1!
z4$@==Kb48@6aP7zWAyh#rh6ij=v2X-14!ddaU1IUDKYMRRdNxy$7UhLX)7^`84|1x
z<mU2cta7t~&4Cm~7eVy;cbkh2t%U4%yv(G4ySQYDcLHOy6H6{VCtXw_*b)dFZNBIb
z0N)`9uy>kNwxagn!Lgbxjo&nW#UAS-^B#sna=|YlAKf_+h6}x&L-L~KP4Bwtv7Q;E
z*AIEJv?^BfIdRA;kxF#DHJTpJ`1NS?@^UkrJ@ui_ydPb&mm|n63VFTFy9Q_q>^cuz
zs`J2?ISO17O`40;EMk7FaROh}a<OD*)A5<*i!4&RgkLz7xm*3h7Wp9x+?v(o#akV_
zYD2mI5wxV+#t(4Y_@=A+#IMQ1KKZeY;>4>1KzVE~*Rc?%a~(TINQU+vQZf*gFk%+r
zbrQP8DnBwSFjy-fw?zG81xB+1J<c5)&6L3dAyjf;*!xc=E=n~kf%S+jl$)+acHIEN
z9UKd>mm5r~KdxeZ+{p4HlXu9!jbtiRh%YHqwghs+Z_lIyd=JECWaNG==Aut`<8X7y
zu|3eUOsn6@y?0aa-sYzF+)A!>b?WW}d+=RC2Jii=gLPmDmTNHxSI9n)#b_s2EM(Dl
zC2|}BVr%;P<7Ld1YYl|_@=pc`;7#NimHD3v?lrquhh5R+E@HbC`JP>hIKg+kt^dv)
z=v-rZk3i>KU^y%st+5=1N@<P`JX0G><BIiQnEYgYy*Nv#r4)BE>!nG9ViswEIigT%
znPz?~9RZk+KZ$;D&rX#T%;$;UhYB#uxAIf}l&#@@zQ?HgFrNyK@!Q}TUmwd<<2!y1
z<{w|%a$h@xuj-?KfyQdE8_P#cF~GR%pmP%qvP+-I5eD~H8a3BBY+%^f(sLkbo>Op3
z4E4oHtW#6T9gA<FO9(7hxzSq>ChJ9e<nRNvN1Esor$r3YCpAw2_;U!1b;S!>-h*{L
zw1wGn`(_zlP0`S@`kMFaoiSug>ylj*-qT>C6U;eWW9#s?T&Wk&1MdhVM3jsc^^t=8
zyUAO?YEGTfV=AzHHx3k&f5_D4fw3Xz0)*4@BZi`T6oPs*eO;k3Pb{8eO1GKB&zrr&
znFsa_LrsRsu~~JA1&jPRmt)sR^KGFyPRlsHDxs-q3G%7jqGUBPzA!xOhf2-HIhfLE
z-zl#Q-TurQNn)lclh)Wz;Uuy1-vdSZmr|UAw*-iS_x02CwtClyX0xNeI$VhVz&?Y&
zh)DxaGx$p|LB`To;FG!4N&M+YdwZK_Y2@?ymL0hrwy3T?JzLI8w`A^(z}C&Zkz3fr
zY-w!ur!z906H~fYlktaB5bR&1q<4yFIkN?N6kB<e=|-RtRLbkqmld;Qg3B`Jjz0<w
zg%X4Q_MFB9N<8bd$PX6ybN2zBRA2KMDDj!(k61uVP(%o~ZambY#2Z)W#T-gpX_{o~
z(HA8;gc7~pU8eReF#870%4s>!R0m5lU=?=P*KER37!MiFPj&G*F@^2x=vz3^)#ta!
z(}vkGJ*l&KPpNa~Zg6Kbx!YdnlOzIVMy{Xn{PWKbbncwP0;GpDv#Y^GMNrXn-K0*_
z_{BV6KQ<(sKBu#Jcj?R*HKmCZHt+dXW2ro5Ti$5h+lyD4_y8N{dwwp59j+0H7byM>
zM6O3HL9ZygjPLra;L}(xe!@`WJp-M4UggE~z-Gmf*hnag4z+VX7MUWqpXDepospc@
zDr1paQ4q>RD{uQt`IA}S^yPT^0hKyN<t)6Qu)57Zm#%e`y*{pZX-CW~8GWhKGMeXX
zR|}&xTN_W9#(6(6aq{XMIQr7Y0dcQtbm@(yR3p^i)+XW``)+!XO?(YQ5<zK;P`SZ-
z`bi1W>mD`FQVEj_+o^oiu(u=`lc`AyPC~F!S6Ztvj5@0iu~;on3y=?*%355Qi+fVS
zu)SDvzGZ&^u31z6w9MvZP=*@~gT6UMB>hj;3?YtfI3*lY(2|m1Bvj9|<bp5(cX;RO
z4ziUIG_D}TB6)lk6jT&IwN-poS{}WZSt|q76FK-LU!?LZG6DIlFv!}(&RJjcKLyi}
zL(amo<eJ+zw9(Y<yPNsjbdZ9HlWC>tJzZPwYTk1uTwRs#X@k)=?-}hRCW70|d(LoL
zhVw;nZvoaaCsDvJdIFt)Zrmf<fwUXnUF6*Prxq5ESjuPCwk`;7W*8KQ8mkx@Azc@Q
zyKPBf<JT$arxMMVI{g|4Qc|RnEtIt0WoEAd#`j>P|EW-sK)ws_3KJMjF{ewPB~*sK
zD^*P5B)VmS&3jIA65VFZCzD1TMVQlkLf7!cJUy0k6IyECQ`Ph>;+@3z9O&HnfFSn|
z+m@SlL(^{GxV>Q7?avlfO-p8aSnVWM;UvPDJjS4vmf*-wW10d8H_^Ts#(Yz$q<Qyn
zCou#&dh>1;<5;T2(o;jsNh@iV>lP|nPI^7x0KSmm6>!B0^Jxyt{}`1EwaB%6L1DmZ
zl)*X)-8M?y0PEZo3Qd6jQa7_$393z{o?4m2r#JC!qzHxc_z@w8DokP*YE3kKHOGFC
zLCYm(v%SdZ2ikTNdq-U^t|2uAZ;l>y3JZ}I;HGgdV4oe@;g$DLCtW=BG&C9*j;Td2
z+f|#eX%#ecL4%q}gr(QyU2SNfcZuI&IE6?t>f;n5Eaj=}+N1+iV`&_e`Ru(nypoSt
z$`YSI+9Ea0e@_cw&+nS|T;jCcNRuW#j?lIx%1#pvztCU6m#lngAi+9~$yWP*97cC`
zNX(Jpt5ic4zZ3+^g3k(-i`#CX_4pnbWRz~x1ApSa<i)#Skl*5`33$|xJDXHyUB887
z%CbjXaT2fbu75DpmXU9<^fiT~de!Yq#OTRiDn?=Jf=VF5{fH5jb(G}I<CFipc?@PX
z%{(^fz1%$3@^hbg{HvLVWk7N%N(|s#|7`wb;fXH7?M<QuZ}kem9lr~dg8vvJRYvYV
zW6I3>Dp$g~%jgKXe}}<7$yOzX!yC<8%oE>XX|wzo=l=9q4NMZKI3t1B)eSRO016;l
zEs%J;7EG~~6i=xZ-;4|?T{pQx>so87W!CjULm}YyB#MJZWcPfX^Ky}l8e<{nn=iq0
zJ~~Y!^9_2&lJ5s1q-6ysb_#nHh>0wr!t>|xMuvd16z?V<4RrfNc(N+=q38@Zkmj!8
z>7T|l)pTxW;?2N|MuloWn*7i|!FY_&)mTI+Jo4~8tOIgae7>ceA130wA&e@18N&Dv
z)v@$L*yZ$^+YJH$WsAtb@n2JCv%x!<ek_!;s9>Occ0QE<4JhBc50vLyDBEcSjmRMK
zLwX8+W?++JXaQH`xu6ZV%z!n=C%*t-mZpr#0N8#JWHNxwvd8^`^Io%-8Eo;6T9*T>
z|56S<f>%a{+(dX#BOU#V<ilX}Hv`y5KxkW*jpu6ws19Kjwza_jyP*W=7meHhn71=+
zuH!UO@~GL0yyj>PQm7ZM5lA6~7@CS+F#4Z!=k<Jt&Z^f+fvhdKeUDWjt8gcPrk%xX
zx7$ML^Uvu78yXLE7M8^QDk+Yyit`;nEkM@AnEYzZAv<2-!M}504I{|MgA@0`gMiw4
zEVcE)gPZq*2aCQ04|;I~(f&4AJ2u9QC_s#0{dLQ*P2)@(f2It)+VEgWPuLsZ@Ofit
ze9r*q4wt5MlSN8`Q6x6r6MwcMUu*b;SNwO4+k9<7rk$gCtxr4U`)j8vXs3H&=DiX7
z_8;5ddu73U{w>nFO`JXy%Xth@QGX_;FFOs!-%#${d7p|hTa1S_g@EHr7XFss{uF~b
zMzt_H#rdYcN#?R#LifYi2snv9@+E^It6<YYo0j`^CYioMDz=jt&A`Da^l>%~+Bu-`
z4x<c5cOw^9IrkjL&oA9M5F1s*(kz}NR613<nzjw!zD3d`yKOj&pI@?Vm>r%jKK;$F
z;?t&^K1^ENdGpP}7oI`rcu!_{1{kFAQ23zvqKkgD08O|viBGTpiBR<!tif&0oj+uD
z;FiJtNr1@GFI*|P8C4P^Tjfu%?CfMyYW-9Rh@itf1w^o0z{FHpfY?@AvBy;}um2^W
zR+M7m;f*b{q<$u+RM@{bw~yAm>Ll(maCbxL>pRh<OPxEUs5I}s#c8>LCuodzyL7#&
zHVL+kE_q63S&z>x>m5fjW=?E2tT(AWj+n_3vW<F+^Fh|QA8XuLY4raKa0H5Xt&e+=
z(MQZ2M5V@(_~t5hpt+3{F~!VAYCFI)XDnN_hq~#HVrthdFllKsAg18aaDjp8f&jLU
zTG$>rEC<`083nL?k9r2#9svok0L^i6Np@PU1Xa>wdgDDM&K*y)lJQT;)v<st20-8C
zU1uRzV>|u7<^1dYvsBD|q1=p}JO9jh1B7n;hFw2I-T!{R^ZLv;`KX!i{NO&9-B+6V
zK1{tFE(P;_@`T)c9R?rZl9}%_{MLM(mcR22TnPDVIpkveTBL+4rFA`S8aaN80l*QS
z1^fTCaQyx5{}nXr3;X~16rzRr|7v7^Gov*GpHN&L8a{}AgLdUWx8HUb?62KNY`ZxI
z@h6;i5blBEe9wja{89#i*fwB;#P~Ek;?JPE;Ssx-dmfMQ`1u7M!Op{|b81CwqGn$<
zaYY|>&UR+kCQ#?ZDbi}1rP1R&9A;NffkYo4tnqyFMSQ~Y3#+hr<BrR%@oP*rz-hmV
zorJ}=eb((>X2`^x#f1uFm#%XWyRS;@9uSD#*R+GUmRgynJ`VJ?2D|gn<1oHMunV&v
zvB1s%*{Q4xPtu>M2A(Idz6PFg#+C=qMy*R<Lk*_@K=b18r2TT-sd=C@J=po@!EvaX
zgyT*EShSJ>C5Hl2DQOH(&B1Pg<p;kA=V13iQ<gr2ryFv3D!u+Fo_;~EugL24%`A~q
z37co=PU1z>6u(Ehij||5*O8ZrMv!OyurI~5;md>P;IDuu8*bBl5M@h}?BC&92C5&?
zWFAyEYMA?j>Vu|@{o?4XJiunUT4a?VyX6p$Ce<+bppj$%3s7wUFmSYua(=V<=Zm(J
z7Dod({}*{pGBRx^2aW+^3C_u!-YPgxu@lJOJ(UMgW*IZs;UwMxe*OTn!z|EyQN6eC
zzALvrU1n7C4MmwHI*;Y`Z?kyqeLT@5OHa<D7DDyqA0br#lkHt*zd`%SMg!RVaaCnk
zzs<C6gQA+&A7Ehqax=O*_U~;sjiK2&YW5t{Y=RdM^|#Qk_p|em$H!~<=`$`;l@qkF
z{5$>mKjjS8KOK1azt^9abtIcU<1|$&q>{_A=QJK<_P2^ti<gGZkU8Z#hS0w{rE<o-
z0wFdIQhZ!5X=d6~;Z}A(E)~PQoip&>+ir9C!ibt>3T$@jmvRPG^8G1G`<@rs1dh}n
zkUc>yQR?(Nf6ZIEVw5_|n8GW2><QkA8wc5TA{R$!3;+Hx_>6qQ`E9iQ{h}BleJelb
zjIr@xolb5$SN^MG82Bjm8}fc3L@?QUkI%`UFFBu!)^u{tW-LNKQX|P@xwBj!`jDuU
z#uT162B5b&3G_C8+vGFG6BFCeEB}IRDBe-wCdYSW^8?q?QeNt7L&q#_<00`qg^kB6
zdvbLfhosHSoT;DA51k(tKX9T>&IXug1%!Xie7E&d15#)9c4hN<Xrapbob;EV>E1l7
zV8!@h1&ybYlN)YvHsg9#!0lK9<XQ94;nBUV<0<{XB`iHxOvZ)_3wnnvSuti<NcO6d
ztPQJ4hq`6oU+SI8WRR~qXx+Cvb4S@NM{bo6^SaDThihQ`?(cStGryg|c=Rcz$#*%4
z`ZoV3aXQW9`gFyV>8yOI*D)zeH?&PV2T4Zoa+x!@zcZMlh)G=f&$OM7VZd(y*H#YV
z|2Xp257z%$AOe^zy%5h^e#?ynU<JXGyNvm)x6|}o0{pcIIc)jjZ*%I8i)qK$V4k))
zylOr+1_ya6bu!{H40UYT_p96FhM>)F9fT+N{gd%E-(1epl@}<9(b=5mZfk=h9^iJI
zZNXTH7wPyiDiF-uVN$fmRl43r&ig+s@m>TagPCOJyYGA==c`Q{jXHHniF?x5@f4BA
z1?T1F<T#3ph3Tttw#`N?TII&kjre7(_tHXo-34|-<Y2$LEy@WlG1PV9OyExiTySf4
zH*#1<R@N2L^H_)j_<weABECYoiN3v^KjUyoSVNrT%H71>iz0DZCF`?c=mdS^=iWo-
ze8C^Xz`x%;BavNh(tJ3rCD)6OeHuyrPx2MF=AKp%aK-?h>I=-I#2q!Jtnv6hjuUKC
z%H=$vnB#S=|F&mZ^2#35yS>rk6~6<Sr0g>?U3%H)*82c&0zmizcOqW`@KgH`#AH?=
z%|RSo;l(sgipfTuzUnL+$PN>6c(46KqhGOK$Cl^%t7i<-vD7#44R6$8amGL9W+D_d
zoe@p5LKD(Mh8zF1528u@0h%@d0;p+nj&Lu8mZoA&%GjL27UakiL}fLX`Kq2|kA*h<
z0msc%W}MuB(t-TQ7$dILF|F%;y^CvyztK8+V<sRyW`hh~WxW*}8}L#Qzq+0vWI*F{
ztPrx8dwxvMw=I^h#}xk-e$C5K6!jz259<0)o2R+QYR})Ny$6E!gq2hLllEyZUHs#r
z+4$|=({K*;ZR_?j=6(Em0<WDfuuRF2p)9M!U+Pvc`Lu6om^Hf^4@|z~eb<$6Z#)sP
z)0byCEq`HDVv)E>8U)Jn^KD);#Nx(#dZFbrdZ{+^0PhS&)cpi>8)+>H2kCSEXyE%(
zDtmY94LTxUOYtv`qyN-M?+y0Z6fN^YysH4*HyRec%^M7L7~^8_dngrMA;UTz=v<+C
ztq%DQFps&>v&_5av`~RRN^5vIZAtW>a&2D-W&Fqf7w|b!;|t*P&GBCfpC`T?K2wEA
zg3pOhGA8^^I%k%7Ut{py|3K-r{5ryf0yzEJ!09Sp@}}ucfU*WS-GJy4oc?OpXtDP?
za1fjb#3x+veDlCbTpIk|&0r0j9uvT_a4Iy94V->B0yxP>$vZ=!1Wt!vBkm3T1X>HS
z)F?=t*+r_7OFB6^md*}swRt!I%_t`ViPmPFsEsR$#>@FOe$=NPHF4jge0BnwDBfGg
z8$J%}l>avwu(01~Wbx(1&)(AXex|CDVIZ=$c^(r|JCEsoK7SjugHaPmjJ5Z2h>-`6
z!5Lv24OIkUPVK#&c_rK4{j?Xw?lw<LWptoBOb=IwuTXM`sT$)+8N3#YPt%9u^q!)z
zUPN7WL9M0@rhc~JvrNOY2_J4+tqOit*`Gs$PDq4tHMh8V{lM;%G;8&Dw2>vewpE^i
zO`f-OoCS&My=&gccC(HJjp7Gln|+pFi#?_y<o{f2onl{lZk1Uhf-N0qL_)tvd2<D~
zO7Mv3pst}|v{j>J3eTE<Q1xkdm-Mmg*;0<@?q?A`teJIf8HQeN^wiXuv6OtmCUGdV
z!j11Kn>ony&IX0&+kKmN3nS?Mc^01oNI5NklY0LGe{8*A-cHNM+LV;$mkY8^%dx7j
z<FGvSM0|w&DZN>jxZ6K;&9XO!EAnJgA}nz!u~hv2*B};lP9>_A4nFbZK|YQ2rb~!$
z&MKp{$$P`$6=CqbVc$WFaiUaCxeg`uTyFrFM0i;6qXcUWPCdUZY@FTZ5qc6mQqkg5
z2kLHenP|aqN(w8GVvRR)0ak9CXp9&M)LtapLK7F0Xg%7GKg}gHWG9dnZBENf`L^7?
zOq0!sx5%XkxLV`c%D4y`%ZfpTh0ek@|9VI{z~9Ku@l~P5N7Vs?lbBA<%68m%=e+pJ
zqDU+A=uQUfLgy916l=YM&IlDeBe|y30k@A8ZvE7188c?N>8A_<S#-i*P<@mcIMyfU
z;Ft5a`*|^%99!b;5-ulS(VgTG%pOFVg?)UwU^>jarMqCmP*`?-QlB28MCH-cx4>>E
z(WI;RsblI<wxX#CY)#g6f5Y%4Hw9JUw>AQsqpM5p$qwF6uA~X}Hcrb?Do<{Y)~ssc
zg56k%;}rE&>&D}nKxk*P24C1XF}sXM$5)mZPz10tOJ3%G3lubbCbvQ`JOj<3M!7}a
zjK0lq9+y$tO)jz)R*1UDjSpa5FJ$X9zI^B0KbWqIpfi?^`_}0Zol=`7;lSB=b`~mt
zW~6r%d7o6`vI0nernB5QKw~KdI$Y2uHNC7OgzdCw0H$+uaS#Yd{Cp0i=^tUxAv3<(
z$tZeL5k8Fzgg3P=aP1zPkv~RJsaeu^zgtt%v_txsd@vQlfkDh-5K3B-SV?!@N8idK
z$8ztoF<Rou46JFE!GS33A>cHr`wY&cpBBht$ywmWAB7v<`Z~SDt$tyKZXOcd49vJ@
zx~4Zv`0#Ok`eLp`3L!?B`TeF$2yu8lOCC*~1449m!>Vg})8fM-PQLo$!^Z|6=Bqr5
z58RYF-Ho>xOi*7gR<yij>#@+>@3P@{pkoBHYy(*~U3;%t**H${sZv|~8R=bqu3fgt
ziUS8TXfbhcSh^~+bX8iqsZE_)x}Y;B@h{+!T{>Zuw}en9{y_%&ki!DgF!(J}_j|hO
zE=z>|IpkMz?!2719d5el6~;|X!``aAHE>V)@>b!lg!3FxH71@#Njm<psRi!1slPSr
zdq-R!`e$frAlM7=)24K6^(t;o$@_9Lmv^PpSDA{!$?l`(MN<V4X_5V-$*O2_d%f&l
zzoh~ZD3nU7dTo93xfn4kpzM~mTIarwXw6IHS<<ESd)sO&I+_;C2mVN!k$yv@5_YfR
z15|4)s!tZZ8ci3ic2mgswT*{xQZ0=%d6<?fS!MIn|Fl`-R+$OyU}u!%c=XHyCvluX
zD#mQyBWOf4Ibwx>o&aa<5HT`;PbM2tBX=<s{2^}$?AIELsLw=hG5G=~;rMbftAdea
zRxCMVx?hVSD61!kuFe%*VYAdq!fZjSiH5dn?FN9QO6-ym6WStHxMF#8@Fd#eoZrlX
z{2)u6#2UVPKRG>1UQ4}V)9n=?&x|jUmu1P89gDo&)E^9aH46d2n=3?K@3Q@grLLNV
zN6K_b81+}ZHoA-O-hC;oRX(D9DXcoTVad>0BmPkNbVfsl&MsE@K6GX|u4n@g<<ptY
zo20}9>~TDq&2KE<*=*RO)AErK72^q~Rm9ej8`L`K{zf!)rZ?c*qAuONXqp&}ufQXn
zB->3m+bl9iScXyDgPqb+Qw!g`#xtNMCA16Ht3Eje*~vxUVg7s8=$y|VFEIRZzSfW-
z+cgZHYtsjRY&HDRc>9=z%PgZ<ie#adahsO$Irbn~5qjpCtVo6{1}hoJQGy(@x@IZO
z8Zu$lDXxVSdNix8KZ|}b9IH@ky50!CG1JYu29>n78iZL}{b=S#EPYgG9uw_`8M4G$
zk?Dquk}pl1v{L$?<)d$X$@(tKTVGKeLL3tf)}_oMkIi3Tqju#lu$#U#v%su+>e6y#
zAo8z>WcQkH&C<qiV9fN6kA(~rS>SKF@ugTy$<AXJIB3#I^vkl#-H?>`(@`w&Hoj%_
znA*wQmow}5v}`pxEfXIN*6(-0`r%Itd;%IYz^<|Iv)5U?fozR}<qH<!=FuzyCn%<}
zT}vbIv`P=t7REY&`G1Ie6Y#34>;F5EM1s}c;FzCd)TlumK*f@xk_f?b^~O?1tV3yQ
zEe>sIO%%0gXcFP{dM&NeYFjI|+ERx~TL&D#Fa}3ZE8<Yac^{*K6CetCKi{>_x%Y;_
ze}Dh?d7n2A+;h%8`|M%uHSM+6URzY?KM1l@Eo*i>D$^`a=GWUChBvC*EeAI>tTTDg
zu-5jal>FBLBwG)dedsCGGDEfS-WThGGKp!fR-#^RG~C~0%xt)Q12ecDC|8;gCk%Wd
zMtkd3I}%Z$H+_3K`bC9$==CZ=VY=GlQ6On?Tk8}OQFnYiVtl#(N`i$+`@mhp$VLN9
zs<o1fI*zM~{%*bx_MFLHS`}?wpi{FrN$S0!1{Fy?czSBGkGQmy)f<lZGqE?uy@<vp
z%p4Poy@hVfP*QRo(^Z}LNRYi(bp>4=y6Dfu-Yl)EK1#+`QWCLuPmP{3@M@wpJ|*!t
zhG#2htc2qD?rOs;lY`72isj%?3M`U?Pap@=Xf$39T5yNna*!j3VmXMUlN=;B*_z9n
z!jULJxsgu-E=fZCUQ20%q#>d`k%m)jK7dKkw1g!Zs9x|ImzsR6fXIgY0=&k%+v_~M
z#v8m~tFHEIf>*32cxu>!rcfP&te2*6ry+$vHm-rt7JzKL2U*OE!dne<yZ7?*7xV{?
zA}og64Rr2*1Go3L1UGgcKZjma1h@4XJHd@J-Fv}Jiky^$=xgRcL?-K#pE}&p%4gch
zEd?Q!=qSWsZVC@t7VAmraI5Hd<_n<Ad_PUsST7kHgdXJ*z2w<)WdWIN1T!^b(qZ$$
zl4xF@e@QQauY2^9eu9C(^pl+m)uTl|-CWL>bTT{9RFrY3C=Y1(q=;rhH0iK$LUdQb
z-vSYnZ`buT{<gQubVb~>@dl)fIJ}znZKGKz!H-@BJIwSF{Khxmv~kunzEsoDp6WcG
zrFFZ-ts93HMbRTBL_bnsmSq0X6ta67mz+V-Su`4XgzBH5^llP&b4=|u#n(q9Pfb2s
z=?O}E9_Rjjq=4Z0Q;gUi{oL_K^ulg2-7R4ES>WL&dho3l15aVm#ePwVGvS>zi@6m<
zTDi)rb2?Z3<+(L^I(hCEfp4NOs|k60&xB9*;u9Pgx2e9oDW4$QrhKBAQ;B+O%-8fD
z{~6ZC-s3;V)Gpr#)0(fb?sx=cLpT}~a#VOQOJCFLPPLz_pdfrWAV$@_5>)jAC6w4U
zFV{lmyfJ2||6oSx5Di%@)<BFx))C{Q{bIkq0)E`;{jZRl)((Xkk(}70j7IfB5*44C
zoKboKNjgb%cMBCj5<TRRL@;st9p>B8%0o~-UB3w4rMf0!E<3YTk6o?0=+A`6Sa2q2
zbFGcqbK5x>xqfHO3cUnAYKZ*)oIQIXENtoIS%0cRFqA{<a<1KbNFVFl7(NbvWWki>
zJDXprzj=IVV&T{3S7^NrscCc5b^kVeS<3vXp?a?7S1)OD)3^8JhHNNc;Ze^9xw6N5
z&9B&flW@jsRsX{^t<)D}e`^=sh4=e}hpn+eIMh$IUQ*8iPA9qPy%ZMRvV(AbbS!A&
z^)lg&`X+d+u&aj$2Pkh2ZwzD!-e_bf4!rTC9AqaLXVI{LKXZ%6jAq-nxIOyMCNS3u
z#zza1I89hK#%GM#Fq4dq0+~Es=l(Ta)pVKo;|@q;nTejx$HVaCAO@g<Ghu)DRS;H0
zUr@57h*)~`8R!~hJ6g$+4zV^E_fLBc{?&vmK5jDp=oOB1*e5!lfEFr3tT*}qr6@0j
zD8i_;cM+Ps`66Or)hD`^a0&wbbZVA3yMZZcTuMP*_acCuyNEM1@OmboPxqQHupfA7
zUas|t_JkED<H^uQ7i$h1M^4s05>*ytC$;J#O#O%5`QCzheoF84RE^yx;|RT|`wv>&
zkGrO;n63_8^rw}%aZw=X=I)qILebcWx~7m6oh5k3DobJLL{P2zf~&A0+5yLzJoa?8
zPA5%&LHTt3lFK*EQ+m{26UTvrS%2C3V17#V^Tk2@tkKU${GfD3U!1J#!sx(L{PTJ7
z^-{Yoj6RC5yTsQ|Eq_-uF3$HF*TVd|V|DJdy@GIUD!pv(y7JQBs$uo37qJcHPuyiN
zI~fa@#zXkgsdLxub@Jes=DxcdM`rBI3Qbi5J65zW{E=!hGz?fu5ONkpPRyM(4NoKS
z?d;AC;R}Q%Bve=U?6ch?!@1ACKC<+&@U$<|bsx99hNXINI``AkKr!L>jCJY?_m^wM
z4l#OW%ztNGh2<ey{jnh>vm983<BOF)f1~wB7OeVhgAHEOuCQ-3`_PTn-?XgsNGpwX
z`|!%I|F3-Xyh&rnl(gbpF^D$|czqCGN9&3w1zrv~9Mo5*`UgX~j^+P&no+?i*yTSd
zlg+<xbj#t?l~;i`_P@E4f-(v=&-^p|JTstk^ZqyT04n(3u<Dx`fZZYXzxnYY0t=49
z**@O?MxnAfO8daVcy8nmFjxKnY54;*;1BS8%L--#iZsyW`cT&Y!42no=i!EP=0HI(
z@6Vt2D%#XbWs?=&F%<wNUcqcW&{i;OCE+!&MT-r81~MAbc!d`?B-y`Nhnqe~JBb(C
z5@rh3H(98h!+STMmu?O}Vk)mQ?2oaRNT$$jpc9ftxxvs6vM8sb8hzp<-Jd~^f{=CG
zN-_lb^-0{{NVfIKu3eZko+=qK)phe_G>UuoD`ki9KEqQduRrFOhT7h%KR3vhS)gLg
z`i8O|B;Td1%q&%`rKQ?e(a}d7Kg5Nq#d}QzojXNKBrGFhFkRrziSYNuH=#sl%qxWP
z!AEVq6&$HLXlpD%+0bz$+84ya&QKue<8h=qZt)PTPu6ORoT9Y7oO0L`Zk1~3uOX8g
zvR~;|Y`KCyTPNbiv^V>XsuwlZGI#k|4JV*}5IZs*)f3>p)X=jdD{l)2X=M;uNKw|C
zGYwuV-GhKLI*|t}PXM04SR42lr&*=6EjmH)`=<H}{JstRbUmIc>*4bCkeAgUTy1(m
zuoegwY&nOaJg@?}TE@Grne5|QV!j*CC}FEoO=K}W(zH$`U=Cmm06S|s+o?XS-IUo4
zv)Rw(#h@j#kGOdRMXkiuu;M6B4}Cv6$nHo?mC?YBSQS3F(&%bERK^drdZ>yYXgK4U
zN9dMqL1yMc-d(}yCz8Vz;~OpGy7Bs=FbIk_#|c~Z9x8Pfw8778V#$H1RXWBQuzvFZ
zwh8q;KLv;7c&J70AN%2r#2VDA>MBvXE{1U|v%PPtUE@6KVKc49+;yxb@y$EZuAvEv
z*m54@Z?-14Gb6?-4IRFiC8H~<6PqDX1(=0;b5oc1$YTF{Et9+o_iM(TsS*aHc0yM`
z!P18Rqq`z20BZ#+NFsv8b3hqPUgK`Z8bjO$(|_4y?+&C}L2kq#^#Z4yiz|b!5tYhJ
zK#o+q*rulRRZ1Zn#Dc3&_pZtOjri2*kkQfsFVza+ab;8ZNmKU7I0DZEL2<YTB5?Z|
z!C$u7Uw!2+hUFqRu10{AMLAc7XUHIsrRA@HqEd8LjYXaa2;ZaPiZl^^F!GCpHRe^q
zxT>bGhEo7mw@mi<&$<zNR%_7@Zvmy0tx|p>a&sJ}D#B&yxo`J5f#Z$57Thu(z*9Jf
zV}_@q(?8Q(k7pVz{(Jlv5;VkEKsX2aV4lFJTg!P67Tm$YwHp6PIy{KR_fg2ooC>V$
z-WU2K@MZ7%nx`^Hv#LZfEb)w}DivY`I34stj&?!Zh^i|3Gn4UHpUzz|hygM=sdxyr
zwoS#I3J9f~3^{Qld0Q0UzU@7{r;0daAo^yAUl7h@`=(`<`P9hrZlw$xQV){~pY`z0
za4t1NW3fYKY~?Yjno70SB_1O@l~c;gHa27GGuiQh0>_Nfc;YiiTptfG!yos3F)xsy
z8n+#pKywr+X2UsPtYx;JrUqaKR;lT_S6Uv#0fBMaHA55`m3moIZenHkwvtoIRrgBs
zw{0z-daS@^LIuU}0|A0OZ%B1q2e$#-WAehT;T%Y@AYYM>?awqn8gw0JG{Ahn`(bal
zYJ_3em-uyL0)b?$qf(`z2lw0_GGH$dx>eJ4Lz`oS_UY0^BD$Txk{D|UaI?s@>@BQO
znCNQUIMQpxO2s_pxv$J&Bw>Pt_y!`K&HJNI8&};!wkh!&Liet8fSywh7DT%n<F5x#
zEP1=PWTRLRDc*?DgXRQl$(z8#oynKc^gKSf-Do+bX2;jV3^L&=%*sSxg$I@`Rj_Mu
zX~$?}veiVNtEphkz{+jP*3_8O&*L`uyiwCwjwibI^K6$<YTZ*U%bOTv7&XHv_RS!r
z?wc}Ipc}A^>22F<rNP{uK0(`tisr_kt%pMne$UHH-MUo!ueoV|G}W<{a3Nc;=M&nl
z?)m0RGugw^!@k<GQX;e3I3!H1d-wK7;s4pgGFg0!_H4OxYT>nk&K)&Kz8-dXTOaG(
zOH>17E4>p|K90RRc@ovCY*&{;8}WP2>)F1^?0NK9CT(Seo?^Kd35B79y`4-R(gf|!
z;hWN3mDf+wZC#a_I=CHlrX0k01RZ|Uie^rnNgK5_?sVRGyj?1y7}U^nI<lm(GCC%2
zA0!@W_m1Fu8l_j@Y^r<5dw?~eKtW?#CYxGqn%Bz~(kQ=9iDA$>`dx$LXhbJ#6|yPU
zkw739CSqS0g3u=9Q7u32YS5L#!|Q=rmr{WcVcy3V+@HJZy+G)yuhwhBn>E6lOm;`D
zJlUj0%YCf50jG*?6xdef^z1#={-)its2|RY5oe99CqAKctv5W?^6#eXK89l6{;|X@
zWyL%%i!zK&mAeZIEDakfZ_`|P&ktyd(t~i+paxTYi21^T#Ce}E>bac`_&y5tx?9x>
zoK`gu@2f~ruz~3CG*3cUu_7G93E4I@&47ZpYurEg2MrEpKw>#F9-rh5m6r^4k6Iah
zqWgHq`gmhWG!1yVj~I>ax#`?hIGhr6_#+*2vFAfx4>?l$*xvDXSMr^^#~v0&FW@vL
z<!o+zeTi$4#xfOE&6E^)S`jOkvYWezUcec4{f{~^Lidtzwq0Nl?tAV-);&3i<W$Am
z$sP-Z|Fk~n(~L_~Y0F??dQ}hDXG&YAIzP0enQ#Hcimuk?76dl)1A-WhMsC&9z0mUm
z19tb4srf17$9t(6%rv?mbkD=>;_*+~kG@vaexmmU;ah6`Suby)^@sb`{~+J`%V|CS
zO|*WX8otM`*D=OzeM*}Tm%BF&XNHtS%)?~0pjLY|rgGl7wc9@VcKk`plW1|Sffjc&
z_h|(Mz24kC%k56nHwXVMwf_$<ZK3@aW8MM!TW<d|pZ%}fe{=kaZ~vq{H`D&Jz{3Ac
z`(J)>3+?|G78lyjyeP(=0{r*wS&AO{b763Au<sp%U2-~xd-t=w@Wnk0(2LubpU)YV
zkMD&g<2;rJ%%tjJ5-YhLtGV0=?6+HLwybpcyPeB47MjSQj6e{$G~%&}WRvYXGpu}<
zwWX+)ula}V0cxuK6CN5?FCtRzR?>Ecl^<?-2Jn#1j;^q2^hsl-E*>0YPr?E8nP#-q
zF8Jy9ykYw4Wt31<XN*_ql$9f=oLlpKh14378FuhXYgFCQRxV+;vqSzwMVhr&xz1fp
zziJ;O<*3kljD>WdN@tOsCv(DawC+?ZCFOfC+M0T-deHVZ(buLJAFi)>0OvZ`;E)5(
zp@!^)s*nGY`fca#T7qteG2%d3uj63<#4SELsrDP~hLow?D3i)T!{vA*27p5oYDT2)
z&(t)qs0=e1Z_H#&!|J)Ec=2YpJ~5lAfb~kn>%ol~O*I(E1LD5S_1zs*f$PF&DR%fs
zA<kJ+oX%wiQujvlHwM4oy_d%m9IxQB^U<fv2z$8@+5a-JFaQXKmJ`_hQrX8nfcsR;
zwL4pu6lsywv{z*^FL{$g!W0A&e&j;cF3u!<P8d5b&nQwI_>W3I9G|G-2|v)FC-8fR
zg`yyPxxsH<>x;6xwiAmEPSL|qY_pmH?RXxhKKPj_z$jKM`k0IrCPklW#M@|GTBg`+
zJ!k|N2pB=L>OmzQ#;YvQX=#E^li88pgV$-)#COosEG{L{F~|`Qr-s><@J1q^q$93?
zA(-*z>)t<~aBF<zZrlwG@J`D}{|zLgz%+xD!6kZvx?+5FFHwkFrjkIl`Pg}0r}?t;
z>|@y3JkzBq4@4u*)9DndicgOb_qh1^2miz8R8;NuAg_dPwF#WT&$!GIsXhz6rnRKJ
z6x0Lbv>{wrRt4!c2=#sUMDT>kHX4rBqBNa1Rr>7=?h^f09l)W04tThTSCo2S?MZ8<
zid~e(Lo%N426s|Lz0a_oXJaSv`_cZnJ_hzHJi2Y^KsZlLLZl{5*@^0k2sApIoD$+k
zHK^YUqZ8umceoZYJK^8|CBGZ;oZz?_A-}EG1K8M8%=0vx9c29ONY5Y+zzLsFhW=q6
zbfZ-Jx#AYZ{BDHhsWrY-@A;h}s`#BDspofj1ikt_O0XtTJN4!H-37h*UH3<-u880L
zlZrgQTM8V7{0YBPKPbug-Lbv--S@4Ot7shrHP)K?PaZbU@4j}%|Ihqxmt8#mdw%!F
z;TpUD4ZoWVZ5R06qqrMxmfsB}+h+LPjjDZ1{BH0T`CUO?tU0|G{KW2<vLo)r?sof-
z@$6U*Z5b&g?5@mMNWF&VvsD`Lk0I&*8-6!itl+=ncdNu^*l&|+U&Kc-&zpR^?!hGd
zo~y-9JS)j$2OBquZlUGUPmB*90|plH!F#L|trTEuYl;@&`O9y3u?c_q`^NmGBmqjy
zUvfMb^OqI9`OA;=z5ARdL>qYH%XeqeDR-KB2LF8x{`+0PDgOJX9c{MvlzWsfJpb+D
zGx6W&?NzG%{`mPFVT|$Lo5<UX|32}k`Xnh06VA_i(2+gB;Kqa>5hsp1>9gB|lDl7b
zTkou5POe5EF%MVfsD#%5HTouXis$|EDAl<z`eS^(hbwR{vPYSQH{rk3@GwD+)Ht|d
zOI7t|IN$c~o2K`@jWoTnes7Y_M<*n{Hbo4nUuhgC)qVhp?pysm*ZI0Afr3Hrn6GQ+
z%g8C`)|_j+Gghv;-xoGFVnzbB-zLaos(k_v@J>!!U`w5;hl!>z`xK2;v8M1onnHUI
zgqr7%6O6N=5B5kOJo<4f|1K-&Dz*04)ZzK#%u3(V>2XWrW)kR_mR66P^0R_I*l4Bv
zlK#=kdTZtDJb)&Iz+F!DBE_VYyI3oG>4UQ0#QGqd*6V|j-5{N1QEqI9%%0~)is2Hj
zUNPj{z0`e~nh_W`MzVHjdf~{_{gUELHPH^|CEDRBm5FwU@u`<~7%?EiR?jV`d|l&R
z%q_o(cDQ#z-fu=foD6^p{PM=Hssx+W_tp=m)9lUg%k#Ha{w?T-(yGx9CnWk|V#n8J
ztnnf)<3Cr^fMm~K>gp=$ar;tg^an`X(>25L8sRik?O(Bx){KJi!8W5vwZB8QcveAZ
zQyzNHEavwf|7aFD5_nK<XytmlT#<gs>KTQ``X#f%jr2=^WcuYa8k^_08%T`X3oSqy
zBNKAy_z*gm+rlubocP*&S7M$5W*<?k-LWtW(?7qJ=$}uDg8zr{jgGR<>Pr~sk)k@U
za>W=O{hY#my`C@sCDn^BXJ}TUpAMrEccf~9KmHm1cr4u)fBZS$kTli(4YD!CpxyJw
z9(TXJO88@s>k@|0l4>`RyuJA2ot*#JfUBt{GVajNW5kzzy0?C6-8YGn^kJO(fW1My
z^EdR?_lGQrKKe&8#QLaL-dEwf5ziTX!mEY-2E}^n_xUgxZ!b@L_L*c?`N`x!<-6VB
z{cdLo0I60jGz1v!`L2i2Idojf=aB3s0TtlHl=oBICWO$xj9<SMKi|Av0;f~Sn}^d#
z^!QutoJ^A=3kq_iQbU^n<St5aFH=N!<QCfZCsdm%U16&9;K+8U7JaZk{gDXym3;fS
z&WNw~$Jd9r{=b$d-H)m#n~^8;-WI4#lg`VO?|My|$#GtuWU>dZ!a$y>Tj}Kq0kU1+
zuXwP2EhbbI<Hbsbpa*#xYTwrL=NsM;BbetOuA{J2dwE`@>}&j?z^pIOUWmfv9TF4=
zUT;*3gv=mqWEsfIlPj$7B6)Hw6?l0vcAMVvM9pNdOr9LuTb_LSwp!KKH*u8}c{~rB
zmnU7!QHz?W_Wl1UPi|y13i9NJBQ)OsJ9#2`U63c~3YD-Kd7@e5X5`8LY^(fRkS8Aj
z#VyH`Y7vRalbu0=f;?dfqr^Q+ucDjtd<DM$tG6^p99d$*-Q-DZTJZ8DX8nmgDa_n1
zRvSbDe*8C<Cv{ft;c>Znd&Pe#Pu9coH!Dw$?JZ9}fm{6_<VmI2w87&Q8k6Yv?^1zU
zp4ab<73cN)!GMVRd&`-mr$409VmWh6zg}_%R7vEF=i`_`Hs#~{`$1@@9p+kseZlkN
z&Dj^?Ns`a-4P)f3@plQ|UgjHBD6b?gubLO`C7KwWm~Xcm219j6iZP3kzeQUz*`tpk
zVqZEt++7K(D)}jr-7S3S`TIB+tN8of@#``1^CNvJ#^hj&0RlUXIRPAFV}B(}uQ0jY
zc@UG^2O|q*ca+)l8uwG7xsA>;I+VxO$*=Mx=qD217uvi{y6q5FdX={r_g+Fs$S&f(
zM{({Pm8lN+^ApO?d&A4EztB)6f53RSN9l!^?_aZi^tk8a*9XMU@6c4=ubYf^i|kKN
zJS;A6a*OjGl2xBE2|}UfHecZ9Khp)nC!spGSPTW#f`z!@Za3<3qbL>zAMJ@fPS<L#
zS~L29ilaT^#GSahmr3cq#VxdU^qN4uX+t+SY6Sw4cAp=rMlX!EALOrl$JhP17S^j9
zPL~f|u@!03d-As}npU-&-!6MPbKWI+u#OJ6g*^IWx_BObkhgJ5nBu=GiR*M-<*GbG
zH~ggrc+X1r@H|>08O>R5xpUFcDYTUgy_cG<e%0n;qXkAyEcF3P_qL4_MrcUI$%){o
zg(A88H4{mxcFt76K<!Jk;@!j8O*PVYf@KMwNI+TL@}Qu&!H>4BDAV-kn^aPXPjpfQ
ztF#r(JIV8aZ8Iy~*nwKYNOjDhEG8&;gjjN#WDElw&cxj2R^Hj%MtoF~>pE53HIK1_
zuvl7Rnf;yAeI7&^t+~lxwTf_4C|-dNHnsePQU#kzXU}2&;~k_qT(>@xCG@L6r8cjg
zZxbQ<bXFA+toT?f$D<)E%1`RU!^)RDJ}&uMwiQ#d5SG@nq`0ByS$#Y{-PL6+)QN6H
zyxC*ni=`z;^`uiHyLxt<?~AvR^J%Cp-+2`#;r-e~g-NIKLA2Bo?}0`c>d0bp6}eK}
zC&)}%AZ+8X*<KT(dQ#RTqu>YfWH4T5s=y(dFHc6&US-%gFSz(AM1mvH{^GULk54L<
z72>NJm5!g1X!8rt66xtn06VIu^PZ0<xDiR_!S`hj83zs-74qD>Q5(eYdg0r9N)f`H
zL6K<6pCD>_<<QjP07J@N$++Tox#3v7OwtEWy9V|;@6)TF`JO4RVWPip0;k<#ginbb
zYz)Lbx1s{jr^@}CY*N4>Ko321@D<PTi3o!U3uEV6KPb>lzVam!BBN+1gAsKP)D`Rd
z9@k?Oh;}{5Cx4f#SkFLvUKqViwy7SziJKgpZ<0Wz(^x`6P~}<Y&hBsGwt%o>44(@v
z<WK6}D24I8F_l0{Z+V@)DSWcw6m~P%f;OHeo^M%vmoQf;=!YE@T#7hZ<6^A<mj7cE
zV-mK^2*Sph1S*qz03_NWrmI^wR1FL5Sy2fznunpS1i8lPwmjWYMNW6v4+Wi}YWYtU
z@~caSI6S4m4LW5iEhopW#v4>1k<O;b8KC96ZV!6F-m4q*)hXI!k=yRAW7V43<E+Iw
zosmOZCd6&QFWEpL$5FQe8(DO{3X~s*l|M!0bDa6qq%PtqFlU@N#qA(mQqxBRd`{WC
zf!^K_<Yo)isbFlrf@w-|*S|+^a<i4}rs&=`GSzXq^5@EjtCd|HYNe_KJR7&PtD`o4
zIk?B|r`khH$%9bsh-+AVVFJ5U`_IuH^YB|1!*8DNU&olZ$W;H1Kn($ktRphHVNd30
zC1htS-R&oIR&PHwPsnNdj>-n<5?U!Vekf1A@zeCeP4A|h+-xPg>vf-<ZQq5Kq#@eD
z;&5;i`;~1lO?S4{Tu5E+Q`LQa6zBb?Po2;^^%_g{2oPsH-zQBi`gWB6wz~JX)js2_
zqKxY$@Uqr3T3@C72||aBGZ?pD)(g8DXS%ivKol+Gtd{DeSO@>GZzmQPcdaG)a&qP0
z;#+X57oE6almjz>PXccuUgGBgCm<I6rlnQ)DsA$Cn<?%6^J!JCr4|1h={p-96t2>w
z?5V9qy}VzN0>}TJdn@Q+Qy4XI2td||+}!qFb<Y`S3=U^xa{JvrT-X{@wuj3(9E~~?
zNX&4TQKu@&WNVA+7(pE@r(Xjf1CqiCW}SxV6KBMrwG!e|-Qg<5w>pShoymT`xYbYd
zH3u!%rzT%DU_*~4cO@eUx%uo0iLq?kP<0BFow7A=gJHHG{*t~yXgB7_JM3ak6Piyp
zxlwIxnA^6f>b&r@wTnir!+-kXidi%hE`KHQ_eLqPEN;5`<^7Mo4MSX9By>AeYwr8Y
z&r~EQ`7Xx$Fk*TWF{vVUAQ_T(<tZ@wh2{)X-I-sk?}-S99Lr000?*yQgSq?ph8w2$
z|B~$Weoo=E5;D6QlG)>``)IHU;W+<Slz$n*D#_pF)_zXXOfP?3w;smj-wR8YE9uzy
z{o{K0tT3N>NYC*UXe3PY4n5B-y#KwP?d$++pUdj`g2MYN^gOcge4(EAEIgm7=e0}>
ze0$vqJOlMHbPTAc+P}vu*trlWn!|l;XOx4`(rb8yhjv6@q#m~whoDBU;0+wrpsGYa
z;3o*@N0Z}gF24RLzTOsJpVAle<A=`pT5<r1zvE%5;$1CiIISsMlz63w&kcSicKWIw
zi8sU89t`O^a=FUgy|$<4TmJF0j9hO}ADhBe4+>S);9v4S#?&*;VV5FK`31CnS9Naz
zZJXs#R*bTSorba_r<_ML$seu7Xu&3+1Pc-I9v@WgjI4(fzCN+M=d48?qd4SwPSa~R
zHIutboU!4QlM(uX5L!Xq!rAguMPCcTX^y)f%q_Qsj-__VX#omhu$apxIzdOh#xJ~A
z_-|CbG5Yi23O;m4m02C`o{)^$*=h&%t+JvCxRmGqpLpIEqeUVUp0d;qpZz9ZXDrx0
z@54HX|HxXOD_{F{G0fQ}R>BSwWkoWqtD}UvMXPSg22e1xXZa9I3~qCfXn3W|oh#@_
zNlCSTNa=Y&`$R!eDXT$K$<ukUr0rP2C+_^U>zTUTrmlF8T@ur62XR(z`<03hklk1w
z-r!T!z9NWx*QXBcoqCp~-s^{M1&l5`M><omW=)X2T8_R%{^5++<FjRptz)G&+~|vs
zBI}hg`x8u~o$2t|?)^3I*HT-@0aj=~okVtkGRQ*|$7DQ2pKjSXUH3`L3qiJDn)6V|
z(eg^X-f)xJU@LVuQEtKjv-fJ)Gr4;!X*bM=0WlmY0L%@*?ku)+%Vgn#sg1Tvf0~UP
z$0W7vI>#s~x6_VCYe-kR`)=!DR@#udei6`9$whFQhnH1>p(L2|FsY60c-s%Im59t0
z0qlXL3BV?4hK2WR5IzRLIt^gI_5cGwf<$+1!jG~7PpbVQdtD47f}ycqkN5Q_Eib0-
z|0cexuRfsW`#uot^TxlapH<yIGds%(t6^icdH(E%>3OUCGd&Ri<tT^T*{K?-=Vsli
z-lsbHlgo>B(WIu?8!}l>rddzBS)*ObP<LGk+e*iLE0z<z#oEaSsQ6xD&F4$EdGywx
z(FCA>+eU(IBTe!pu-yQ6H9QrGWfYv7U7<nBYmyo=l?LhSg*)vvRc|Bdj_1CZTwX?Y
zL{IQjjAvA;F8N3?*->NJ9x;yMXQ`WMAQ->T47^uK><^i{p*+8-rz?}aT4SCG$5xy-
zl3kT-R!Xl~1;J?iGudtNpnj%Fqx<AG3}m*H$SvkXT@<h9PTnY93y#_5Kh5{)I-Jn1
zSGxSCpCArima`6xENI$H+F@|Hj2y1x(|j9)?5J_Uz)@p^qhIaeoWaSz-`C)_T=}y(
z@!lXev6ZoPEB?xT+r%j)sgB#qRDFl%bT;dFpj>U&6e~Am{*cm=I9hb$boam%72)R_
z9z<wwt<1)z5@eHoI-h-_wsZ)dY@HaF88&`=s{ND-dY&6q$!==ijn(K4Gw`O`BUCA$
zJf38o%}kDQ{uUFH6%@49kE`B@%<_C`lIKfHlU-58<kn^^9I(R4Ah*3?G)8CVTKYzG
z_6-s<b#J%4m<gw;`BW}2r|xIRMrh*Uyrjdi%t(X<y!Rx5uuWoP3?1Ur%}SLr&ZGP)
zuX8&+b_ANO<)5rEZu@*I&UM^LUwR6qEz0%>vbmja@f3PxO7A;Na%KtE7v5x*4691D
zpSZV%c?4MJIV5toz!SljKp@YRD^x5`qB%GE9ILHb_xF4llUX$mye70eL{tf*&E00w
zqsyk+G_1sZ{2yzIWx}k{W!d$H+d+J3x1Rgb;wn<8wpLX=z?U*|rUuwIk!+PPhgjce
zGpbcD^-VLQh4`%9g>vhbr`p^1<)+QVyt1ggILrT#C9NQ@&nvIj1l-?^bdB-Lj^-Oc
z11tE>H_&Ut`>Qjaso-x<@9q^ni6{OEa1d!wJz`r|Qt?fynDaRKB{(QY2XiAi^7jvf
zH1;++j5Ol^drY#^s$GwO9CpkQYWaN_Vj1+qBij^NJ_sr`LzmpFnf5f(&^*jd=Og3$
z?tDV7!sup^AcN-ZeaUT`1&`dByIEALKLQJS`kH*gJ|g78hQZ5dMY3VgeeuD1NUk$(
zLnb%1)7Ls(m!ci^+E`Zd6>+nhRIx0!Q<SHBx0tW9e;_1W3CM*qK;~zSaeXKa;>aM|
zP(dstwgWEpQ{EP?#&Dam_o<XjI5<v7hu8W90<hOHDgFa>ro(O5vUf>=y*09uUqP<?
zv)xP`3+O8_9j!|N;a$y{v|rP~m9FkiQHIS3s6^OaB;B7d)r1Le_S7lqwhhqnN6@j<
zvU!-Krh^pXRS*1~My7T){wSVkvB+VJe`V<oYtjsNTN^^<9W4E_(=7(3Q45ahvXece
zhwFLpaB_F(`FDlq-|P9D{Bz9Uqiu1|mprG%Ca)#&;Rau@Y$x5O{3g#3rfGJQE5Ds~
z6e&ZSf@7y|*@|cRU1aoNVGFydMy!LD-%P5Wh1G7?+c)%(XevF|dzI)F4(SZ3`wj7c
zr*M{!?h*&$YRz=p!Kn1HPpq^=U?`!T$=x=T3t4OVKfc2Kg9Dbajm`E#r~Jl4Z9G*S
z<0*n;JoN>&im8YJ>DCP}{I_Q&XvQDj+ryZaJLC+q#_IL$<n`(`gGtzXvjfi4j*=og
zDb}vr$C}ZimmTZuRWV!KjT-)2?PK|Jjg{9vp3r^vCIKMYiSjue;kNNSa0bD7mC+79
zbm2(y_;v}K)k!$}Mi?D^msdJZ#N&g;0(`jW5RVU^{!aMNlD?ok9-y9krNhPQn-n<@
zeMIPTOYfz~o&F&WI%iDuV_wDjXrdsd;tH<!6;xiZbzDLBO|ky8Cdt}|tnMP8uj+!n
zalYuMYIi=~K}^5NHxC@lH$&|kxV*u?mwtMa-dFke9V?Kl7xYWY-PPccKl6d;%&d+R
ztu^crtJDs*0gHLKfd@iElv`lW-S+@$5-86}{O7hss4PxRo+TcDde))fv>=E0b2ac)
z0H96=-HIsX*pcH=1GWK#VhO>p+$@2s{TcCJOV+psA(^tdaojF46-fo^iSo#HJlx*C
zqgXYQNwEsE1J<6E0^!*r{Xj?T-XDLXa4;LYsP`un%Zgjuyy~EBZZ*%&K5ExTIbP;2
zClh%O3+gtsJj#h4-y*=q8I|3S#(d}Sci}Tfu)QvR-dE3G&p#&$o#%I)A`Ix%KQ3yZ
zTW}Q?jUA1rwW=$LA{xuC@H0D~ZdoSRYC13bhhF~^6yx>O=sQG)N%&s`MR|gd=xooT
ziN_qm-OQ$T?uGg8I)5*!caymnW4%ggey+uyFeWJ3Ns^A4>@B7NqH>3en{o#cF#4IM
z?AgpcDgS$Pk>JBk;R|NwBNk{JZ}@8_rbhBwdN(RPQB}gliQavX($Q<`UT7ggm@&H`
zn`)|iJk|a;p(#^YBDpnKkUwea&3&7~Z3*R^N{9X28tY@MxXzF`FO6Qpk>BK3tQcGT
z>ZZ~~J|Ym&D$%zkKC?Mf4?-d^5Q!(R9JICiV$KJWk_#79By_Mn04$=f0{TK~D$0el
zCX@AAM=k($tcG-HXH?CEFPVSlcB+#>xQM+-&fN4HlQZo@wo~g&r8Uy!9o$D>#ELN^
zE#BoW@*i~k+mJco?K_&SdA4$paU;$KfmHHBSmm1DHw{V832%Q<zS3UmyAw}VGrala
zM>`hrcaAqO{?2-&@%Kb-#6r!lQ%FUGzy_)Ctl4qgM5w?R!p>Dzi@u|Ub}1N-x~i=A
z@yiP3!Pf4>Vq{I31Z$O?a9NM`ZpkwqZ@ajXLlwJ+{JnbU?)LX%bpL1FXK(5h&H3I+
zM+P>dc`MkM33}k+XwCJc1amh~|DsZN<}|f<d63<Wu`>YMCZwD`qbD{$sGHw%SadSe
z4*4&#-H#)w+7>YtJ8c!St+kj|>^tqss<R12s(pVlYtQb|xGfy2#p=2{<TA;WxEiaX
zd$Ff$X2zcF+WhqRTxL*$Xp~@_4sh<BiTSbT(Qe7xhMC4+v&Ob1usib#vFTo@T|(nb
zSkJ+xu=ruKJ>UHRq2+Rv5WUG=GJkL<;4%{(nAfLlve#v_RUlRZ5<oN}SZ(hG>T3n{
z+;!6hW(9y=f%2N}Y82RcowCE5eLwSUvq-S%x^>Mv&?$A$mHOUTXA_m)c)cd{Q;boC
zM)jBnf;Ar|DtWZV8?W2r+Iq>qTiB%Rs;=|O-WVEv!8Qrq@46PcXFP9OLFIEGH&AS+
zbIC80?OVS#ec&fD=fwRpdrmL40A90P9S>iHJuFoh4tX6&dJV7P%)yT~oHYma+X_75
zw|VTgSY8Rd(aWQ4Ej*=ff6|au`}u~PWerJnG)v%qSz{8?*`!Usd#%u>GicMd=3siW
zHcf}uL=PE5WR%PV2YDO&%ubqanf~D~7I~A|iH~IV4~+$3NI-7Sqsx^G6GU|Fx<pQ)
zr_CM@38ng9UKtGp)Cr&T$dU=yYG(7V3iR@H_=?5uB}fkKDvGmkf$1|<NiD?bPlxkm
z79FX4yP5ct->D+_o6*OjEv&;{N@BWhiR=&_HM1k+To>eatcRpE-uW`?tH7hBxTY}c
zda3#1#3GQrNh1qo&(tM*Z>K%oWr^9lG}cLfY#DE{y?(tZ{19q2VhCSo3LSbQ@d--Z
zE-Pf{%hcT_Zqh;=+_+dPFAw<!f(0}T;sB1!0On5526I0z3x+k+qt~Hd88gcT=p=O4
zLp@}hY1s8~>PqWTjCOVsQj81ngo{{Pt84<29(ZDfyW@IcY*jQL0WEnti?-?SDj=hw
zkIJP}7xc~W)dVHKyDzl##4kN9Y5P(UKGM^{&v@d9sUop_7Ko$&tAe|c=NUn+{78yp
z5p%Zj&P{}x`*X(6xQ3B!(;3&nq%sTgGp-qbuo;&b7nnTVR!esXWE{SlzyxNj+_MFK
zuD1yT+@IhI<c<?7EiqQ4V)&7DDF4S+xKU5w%l|7hkhuK`NKV-YkUVg$2g%-M{xy+Z
z!XA&?W>E{_I%Le+0^!~(L@EF(h8!za?ydiTF&>^g##w9~3rN$mIIEkjd_mV-jo`QD
zz@}M}eO(M}0emCwMzp+$zh}b5(Fss#!hd24X$oISXa86Q0r~(;(^g>C$j%XYLRsF{
zLTCz3xWG93G2y*&w_2+ei0sv(+6+|7!iKFjjIDt9q=*saq89#2v<=J|BS`i3+0K|$
zwR(~27^rmFXP0o0ho{!G!jqwS?!v1~_`Hi=mBt&ZePgRL!^YO8+P8*@i6)@0sx+IS
z*3xwj5bi&+2C5rd9gh=e)?IDW;w@m=(Z{P<n$vi7L|dX<8jm7ZWaHQc{GmXp8AYi(
zS&s~zsb<zTUslbsw0ddQl<wb2Q8Lp(T&Aj9RaEdlH6hBIX-@jmf+rRV{`F=HUQ59Q
z7-PguhwJ!|JNJYCAme3iLH@OU&RHqv>3u8-8BR&UI-|Q+-AgQ9%8)mLEUEkBInApH
z-4-lHu|+*se%f9lSZ^VHCGbRiiKVIk&{N)QGLBR|i(cIuHwZ3f)Dl%z3)r*nxZVE+
z*>gs-q!5tX0InSRDjmMuG~g4ZdKKsOVD7p;LF(?MLA-`J?3^)ds7DA7X8wda*ft-3
zgDcji`j2oyc+O~*BW93v%v)M0?+T|^D)hW?#9Ae+at(_$F4H6fXsAdx$l-96n>d~B
zno!ZKuW`Ct{u3Kw6AIa}6(B5r535XvGSjoQMCRv#RlSd3jL&6EwVx^D--C2ee>#mZ
zHTfGtLJ0fwmlK1dWRiTeIy0M|%?N#FaZg^-jK`&kK<J)mO44@*i83u7W!pTaygy~q
zcRaBeyEqTk(_d!5l62|XG_jb7?~QAw@Dm~2IGq&-16KQ;2&5!+rfzC^J)?>6TSN6!
z4StK&>b{<P0fGex6sc)5xiwh?f=f=$k(EB?Q?3$5N^|w8B-Gw)U<5zEL;;IGjF}<O
zN%XM4EZ3NtrS03OJY(iC{W9p?l|#ZUevb<3ScYB7LAP@Wid@bBYOJGvuy{?|_UC&V
zUIp}{1x{%z-S$3BXcs+8S`cQZQ);v$3KV(On@p~?Qx$dDg}aiba9;F5L<YKn*cZ|i
z>5<9U_(eh(eW54rjpwl`ee1sv0S_wUnXvtab7Da-2a#jFeFO)ML<l_FZOt4+^O17u
z8J*T}xbqi^&#rOb;mRv@(4A^&D_xUM8>6%a-TTFpjL>>uHQqpA_6by%3E%cu?fGHR
ztc!V8GUaOfpwzvmMdf4#rs~Apx%;l_KG5d%Hm_nz22P#^PI6voVP0iXE`A1Qg75-0
zeVADpTOLjLWcZ?c=0eV{d?t8+*ZPBMur;(nNDU8SmV(8<)Vxdj!Bzh4RY9(7Hyu)P
z^;~cnDFegM;4l{veY5HyEOghtAkkxQ)V)mBlEE@%VyRJaqxzR&Jjzs7rhfSg8YmIi
zAq<aELIgTjv$D^cN}tA&5=Yda9<`0B*r2GMX;!B0L)Ki3<y)yu;W2)4DFDn%=9c+|
z$LYv__X9bU<P}d&_n0ADPEN#`5uJMdGA1#1<8uNzTncW5+l#F+PGf^Q?`<Z`#IoGA
zlMqu({N3P3=ky0|?($!N@Y96D@seDu8z=R7OK9DgwZuGG1wnCB)HI{`xWpiQ!EI}e
zv5FhUG@K!^SMK_5sq%y~tj0Sf>aR8=3caVd@M$|%<0)2qq=vY^{}RrN)6tVy|8+he
zj%lGS*)pJhT#YfgBVV$Kv&NV))f*^J<8N`j7$d*Vn|R!KWcUs-On|bo#dI3uLsUtU
z+kP2Bb>v#^Ds=Z6O+d3~3g1o-pdnsx&Z@iijiLI-`cYm~&FcEe?)q1%qpaE&3KbNN
z?B9?TCf4oa9t3rdr6$`NX_w&%LnA9%s^e=+U1N&M^to4k5vr!U{6Wm@JL9;!{+Pl(
zN8IRa@44$(L!G3;XL(u>sSp=4QpE_E-_d%%q9p;N@4b*go+NVS9326?wZuzZ!op0v
z7#;uD@?{j_Wfan7RBz$3H%*HZku9T4v{1_|8ndWzCd{>QhWgH{YPv0)ZwjwuCe#St
z$6{wxy)g`(jhAkFFUaIBt_>2<e>FYe<@DV5`eagfugF7Suk_vv2!Z(~-W2LI?hb|%
zxwGbvkLP(GH>7@i<#M`xR82ZN$^l{%Zye5q^aI#VZQ}Kn%S|wnXO*24C%rUI;fN3A
z&5l~Dn`&+<o5D+0@v&E47j11hhw_35fmdQ%(k=)hAC<ee|1EX=%H^ia{gNWxzm?Lq
zC_w)Whya=DIFrGQ(Ew=q=8x>`2cP3$_Ratd^uy^9QM+}Z4ws`CzOwAun@mu{DZCY_
zk5M+0Nc%A4gzEu)upSBGxa|nhzrokh0o)}mA@XFZ<7qP35sZS_F~CGoIc>v|w=GJ*
z2wKpxNu$ClRrE)MRBtY1%EI8)2_tyFL%qCdCRIp9*zl$Xi#a@#o(B?T(WcLw@v>H$
z;N0MWQ~e(+7>iTwKNYoT1!FQc0;c}h2^OV(zJ!OttF;ZM<6vbd{m7(Q*RhfutWa*%
zRJQ;pG@~?cC(&k;&LCV8bV-AO0Hsn9nQ5MmMV}y@%3=CoUbCR(WpEJ6^LBwmrQN1!
zz=F-9p$rC17rt4QF8xGv8{~;XHNnU3T}7we%g<=Q>>ehxmLv_<B9Z79VDKdpF^oAJ
zr=gaKe^vAmDh<Y%i8JGYI0>1<!i?E{g1Wh;0p;+mN{)u`hOB9-#>>L!X04GvSb(B&
z!&LjVW_ih}RSI+|_ne%JRHdvM`L&t4xv8t0mFq&YU{<-|l$tJGAlRPQz@!c6(yFo=
zp-ua*^>KdrMhr4s11!HTn6hNU`SF)ImT-`YKS5o6w&jhWtve6a2jjutCNtpUU~acY
z{>8iky;ra|>zDIOg9~4(;v92L0^~LhScyGq3tX<_X`_Q1)R_yd^;Jd$`uRKoG@u2f
zK~TCB=#GgV!Ghv;UkVAlDpTtA+~MIcRM?&B*bZS8Es>g-_4ek1Ha|dXYzf#x?;pl#
z>}EI}BOnMpe<T$mx4U_5Tz$MAum~~lpZiXkTdSH-J`y#`m_BgNa1=#IP)g4Rjr}y5
zCStQHyn4)UiWvcU6p!BY|I5MEpROe{`u{*{R%{YrpF_HoqX*4EB9%n4dIzMD;o&K2
zL)PvEqq#!B4Z++u@YptaYIs=s0@+6ckXQqZjzB1y<9IX$V~NmkI@YEJbHz(vxPjp`
zeE}`ZDoI%-J}Fi{!bQ<JTCj;R`pVkqWlDgwgVb?S<vFl$UUU#Ro(`Ytz7zBRbcPfl
zlth<MqdS`tF%8MQFk55IVT`HcUW{03>v_m>83uTU7%kAO7;WNlzNEOw+BEPf2K>->
zl=4aREt-OvKa)D{!{{h6;M~zCtb;q>_XN<%9X(w4xBL6Ub^k~1-2;>ttKjZ^j?0$r
z{TA0m_kO|BR=THs+8D}p3%U0`Faxc)Ax9B})zq8$uAjK@Q6*?Txuc)_j9P{&OC6J&
z<1pA50HVuiD6jvn*Z-qN96=-8p=t>o9KOz9N5|JU<7<_C!Pyq|XM667&amhC(Pi=V
zcG9D%@x!Y4db&L0DfF%Q`ZU+*IGn?k_yakK{~~_4P7i;IA4<&WcYbtne7$O;>vi#S
z8`tP}`ng3vFX`ubPQX*?@5I-qNYwLpRKeTv!$<LT16SONql0_aWB(|MmoVu)$zej&
z9bV*4-EODVu#64E*wN05hi80>*XZF-u9wHap|UHp7f|xQXj{Uw(yt~hP=UQ8D>G4s
zKy5K{KVE|IWi>4irL$!<iVTcQzKByZwFy!2OUK&Q$V}bZ<_y%B$sN4mmQuNTjf8Ku
zUP++*eK@^$RCU9mQMF)^Hg9eeDF2j&C_sw_HPx+Yfs*67JoW2nPG;+4Mba#T^(}Qr
zECFN>#^#o-%;Hc@9~4bjagHm4IR)|hVKDczGC1s0w)+3Bq$2a<eeUN<9h8i;qAs@r
zQc-+hX*-$RkOmr$oBk2vZyhH<ZP7RQG}f<d<0bo5UcOD6_9a^+B{+NFa5TR5n(4qw
zf5{%hWdE(MTD$hUT6Oxl`vqjGU9IoJO4-$V1bYCKd@;$K-b>t)F?#z1Z#UZEsnEFL
z2SsNL0H)D`&{u4;Te%zb*m^r?UOwA8k-Q>3?4lYbz*rb5>z<nBG$h$nOqGPbcTJbW
zAUO86Vo>YD_P(U~AXU56veFi{&hMsWo3RRDAbWbZVS?Ha@2xTkYc9ZGj1JMQPPO+l
zL2RL%j;Qf^3#SLGC_!f?SB>>Joln3Dpx=M1tJ>hU1&vMM94d09#}hPM#Z|5YQaZI^
zf;RS!CQN6l;~TKcq(7;S8zr-V>jX%_?S8L+2;BDEMX$kk3}1!eLD*f;(u$C6fSrC>
z8C$<hY11O&_3D>op##2oXA{K-vU!i<Z7BM2?I87#o1t9orb;&%`ofvuy+?&1N#~B*
z%iT8tb_lMrV7oBY{tIOfKgYiTevrEF(pn~!nh8xMS3~Pn(AmBuA6Fd@RKud<L~a|@
z=P`w$BC_=$R0~4FuWxxEZ@OgM-X9bU1W$sw?~7<$e$tT&_GYK)$RBPku@&g>bAi6r
zw<}T5-&?%Chb11fz|qCj&YD7yjTzX0vYO~Gh$e$?G8`>e8j2@qs4*L3o3y=r+X&@@
z+;+qMpq<fEJURqy*zVbJZj6eh(Tfb9=QruLA9CPFM>+M$7`9&*oK+Dg-EO)&pJbme
zLGBn<`F03a1q^2^brF(Br%6TdafTaaYdFo`M$b88Krli7>l~!63^fQv)!<*kH)bd6
zSKW`vuOkjsd07INjoOnmA;{h1DWfokL2jp;fd$*iqeJZLRvJQlwMF#ri#!~fME9B8
zQT6m76Gqa<G6OyofiZgGlS0@oeRvXpvD_AsoL*Ek)qT)BR(M%aSYHFNE&<<|P4u|x
zON4LY>jR9h=kYCO@44+ZunWHk?HDStcVQl7xBROqdk{hB-`9aUE8Rb7xabyk54z~M
znoOz7^tp)e^VS%^Ss9sC-_}#Hho(k7oyi?^QhM%NWzppZ;(DW}3IQTIMtaB|bP7G<
zybtN%)AQ~A$qn2u)IAcnMY|2SZp$_LY5WjyP1c(>iqA0Vy&EXIm%N=qg51WAt4<AI
zC%=A1TQr5^Ds(@VA?zSasis^&ob%Gh(cg<Wr!hOeQtWA3d(G8kuw|zq;uhIGuD%(#
zX_8T{=eh50rETGZ5?)zP?h?gZB9Z|$407+Frph&VCFzKuap?0q@*zqmhhz$z^=!i*
zS88f2&6!L#JKtq&YCy)b$ab7-87YxHC+dur0NS3>P2I<#ndV9Tu8x+c?LVs-@7A`k
zb3zJ)+jAjf7QSw4d>p{D(EVqU9l#UNf}hd?nFj1Uo=jMq>R6>Zm{Swqk#{P4919}#
z?5gRwgVLmy2$)4`$sOwcqy>U`d?1Y9G&vvQZ6{G5*;xP=(a*Z>=27fD{l$&w9QpO&
zP0#0nZzm!w&kPsnd>#sr|BH$eP6`HlE|5k*J3X1IsqLpqZ>H8U$~szrWvIHFN22be
zs5+)|t9PH`bAbkJS}*EOQt=Wi%?<|o1XNb#w}7M3J274-!zOY$Q1%7zAv(ccwh9jM
z`<R~yt=e&e?%`;=2HIPIheoid<>|VWcAn9xH>l<4Y5yI(7WwmxR(g1$bWq*3Fd;Sj
zT@FQ!CMEn#XoI~B!~#;aST8<kt_M<Y{kFKi>O7o^!)GL;6GMqlTb{O(th#^2)m@?L
zBvw2>SO1tXGKka{P~Xbt;o`H_uLJV+z($MCX+o@=LW6vTFsY<>k6A%h-C=Qc+p4<#
ztak=?$=$`Bq#aC}`#W#NPLBJ;Uk{6~-{I=pSIkfR$xV~qo5A??VkyFRSPJAg!B~j2
zh4G}B-n#B*1bKj_s{ytGn2d$l#HaPxF#(U=2v-jAGc+xh_b}IdmZ#s<Y+9!Y{0nP<
z(3sCJsu^cn+Z4A~Y{Ul*F00W*dA@$0^hXgUtx$XgcKQre+p2N0sW-;dCq8+Y6E#5f
zvKnhSVKtG$-xeA3^=S1W9lmGz6BEeo7&w&|3AMt`bW7bm&!keFzUr;wk0wcup??A5
zYB$OUk-#KmO=?uAu^icg#pa?;o%TGMiIbHr+V0<duGWv|BYze^?Eh&#wZU+*^$H}|
zJG!ri*a@Q*M~eYRh|aOyi@(uI`MHvpub3LpK&Y7Nz-t~V&Ppkb3vIbWc`@OhtEI%F
zh$;VeL(eibGf;!;#VR;J?BF-A7Xie0*^5t5&&K>|V?I$2N_qx0@eu*yECE8HY;p%*
zL%FJBSTP^^ujor4GWx2{m%bOJXR`aPg*n(hK8z4TLaG{PsMFnds%MO<aRjx0mD)X?
z8&K)ji0VZn{JCiLz%K@EFUp>8jMw<z*nG{m%~8MFYrM2Qyv&Y;YxxGUK*Z8p78u`R
z>Egs}^B}ff7;P5m0Sc*J#Q(sas@c%%kx~yfP>p-xK~JpfR_VGh`nv7fnIC;(&-0_B
z?0KO*bKY8V0!DQa$)fTN?rd8}=tYGGx%BH=5BaBoiiM268fQsi9cbZulInO!Z`&4B
z5AL)GD|va=wysYLJ4Fu_Bpy$PSoq&@vuXtNiS((FuefJ^<)aIHN3YLMUgwj)HK#(^
zV8%Dm)$TT1=Q!jMCAteqVe<=b(f#7X-vZ8%kv(4da^<B$A<kn=lfwCZ4^hGm`S!V&
z^n9~hKryDjo@x-`Y^sr2jyl?_7f^IU6&$KsE%|s~nHJu0yNPrmSa29tb0si-1hs(p
zG7tE4c!v-9B3~ZUU07R1f(&zeQ?q^araA|oC#!Vr!ff-eyuc5l{QmXe2ownUk_!^V
zAp$)~uWsd)Jq>kxUn;i;h@5o)mcvpCusxbqlQUDpDFxVk-BxsfoMkoqkf^2w`2lUI
zV=%|~{q*dmuU8%UFK2*Y{v-Ro`!B%RT}NW14Q1}KhrNMk!Aeq=@FNNGgdYB_pLO~v
z15PoXA6LPdoq7Gn&XWwn^*R9%D9srS)Ow8pM_C1-PX3E6Cn%~MQTOet)veOGw!)l}
z{Wc#SSDDGx%x4*@`G`z*p!D&R9uuZ@Hur6vK9!ssV!H%OxtNW0XxGav&xykoAhxey
zQc-}(u7wx_`S=3v_l$G*GS{xbgxF4_cSRxfr{*J}(M-;)vJLOGh6#tdL6DRdj++qh
zT9lrj$zC`VM-iNBn{u37&K_%yQBr#@gM!jbinA>h-TN8bSZCH+ck{Q?I^7HBe@^LU
zOZtatEb}L1IH#}f!<LuG&wkM7iEoAVj2POZ<fdtPn)@|{r#uJNwTKcc)8S#NrrfPJ
ztX=6o)wS)y(TD*y<~I*Oho48}F=@M;p&c$yA}wG!c-7r73lO~P`J@PVik_eJ&#L+G
zUN!&HYEH8|Aa`<rp{x0zbR5}%#za3dvaN?DF70L~y$>DRtzb{>44Rn0#X<K|1$?nc
z6xrcw{ef<{S{<Jj*fpZc@^@jTC@JZZ{~KR-ji}c3%>4NI@2^7TOL)-H#E=RKk9+c1
z?SZp`ep!Gi@*Z$z^fZrC-S6+GvoGb_=dyZ!IRAX+{32`+KWcjq`@z~?C=IU-LQc&B
zRA4XX+F>a&huU|vhK`<5sW!X0Q#C7^rTZY&Na{wX+mwTzwe#INnpJ>LVqe8tPN*x$
zie-$p_dvL-DzlAM%-^iGYMmQa8w{IRooYW&*qIy8ChvLa@bh?W;1SizUn{W_8pEY+
zZx3f3d+SVYTO2pmWd^*?lGoDk#bCfvDD295`q?OM_*=ecAk0To_$dedrk{OFo`_1s
z6NNc9-n!4ep3e4b>KNF3deD#Mk^Tw_(lS4M!4@eL+9ta#W~+I@nrDK3i-Wx%WAar&
z??=+KvYLjrb;Fy_X=s~QIx;*J8^uPaS+-IUfghgXv$*8uzo=Oq=YwPEw(g3iaDBt9
z;bhXfqfd;O%C4KEwCH=}l77`y(bectDV)ffO|MFL|3D}C_`50?h(ybku{Ops=g?R~
ztQ6XDnx`1g5y70bK5q(7XfT<ByuklUcgMAWwSuQv4+5(1LKkK16Qb!z1ICy$rQFr`
zNpXRg!`HErWd?lIRQE~qPG)k()_V$}SKburV{WYqUrpzZ*u@(}<a&t30w;*qI5*PV
zSG#xhbeRhnm8H4STcw{}0mo@uS=!7HWkT4|o{Wk=!X4l>^;@3V`^9uezjUf`DJQeH
ztsUMnKixK$6|6-S{z$XIoj$+|Wwbn;4nHJIs(nY}abIO+GSja!y=G~8@5MHD*`}&Y
zs<9I@d}U_9iVVByb4Sb#25M5(vHHsI_!7If&(jZs8-Oj%$ECA%@;2$jqYJ!XH<TLr
zS<r88ux4qn_u8foRDe_?+s;bcKBs<h3zi(g5ZXj@VSE(R@_-f|;jwE3GzG2U{Lg#W
z_rxPC_@R^-xhZ}P=gWBwrK{1i599&<w-Za^=S=C^OxRS3??d&b2<YLQZd+KviRH}<
zyyx3F?bV82vzhKl;l_u)&j!QjQPQ#R?6C%V|L`C1m%Kk!DxqZbHF!vdbD<Fm@&X><
zY^_~rcRNsr($g462Yg_<MMf#JW4ya6$Q^|?y*73AP9$p{B`_Ewx_$2v0tqDz3gP_Y
zb7i$Q6UpQ*q^hlgu<Y=3-Fx_S38e`Rxi-j+NU0tg04dLn`VdTU&(zhCaCa6KJN@ky
zbj*#Ts<zE76{CABVA3}C^)e41R+uy8tnhEk$1I7~Ep2&UtNLy4VBXyk-A24<<W8(=
zzZleghL)%e+E|Y+I=r%}?u+Ifn+CumvGl(U**2A~cTNAK7s+H|5OZo1;eO)B3h8r9
zq+lJR%zsAgGLd6CbJOc19X&0li09gXH_X<B@%thfFP~zEPx$<Bz0ei-t#?F#I_AMx
zk6$bQgZH8gfC%cAVBlMl4xhxn*C%2-q6Ye=|1i)MGo=i9`KEYFJzi-L%eJwWzT^7b
z9{Yx)C%8-0&Fpnk1fJ~06N21BQfXp8adX+oWdEhP1}cen79U&bJ_H<EdI?EK)4=$3
z@%SKHR-@BmKW)nGxQx9pY4%@=N$;eIY4)p`?AZjBO~VuycOMk%9p+-!{)F&Kj;!G#
z^CzbWJ81JBL#)n>_8meOG~ke+txXMuju+G#UoQgsRL+s)&|ts+e+AzbS?A3uO2y@l
zGJYr%?L=sTp^gs=UgXyQ9YEyTrdwB~JZH15y6<Y!MStcPF;6!+OC!)+<KRbG`pyrs
z@!9S@VtN&VA^R%QY{g_gaZ!Wp%*-RT`>H8?Jd^Fu*}7<6^#s_=)G_$WaJ=VW)q3J<
z&Qo~aUFCcayWie#*C99An#-EPvSkDiSS?d3<(|%|yHt^nIY3=4*VpUwAWImb;?IM+
zWz8(BZ_BLvitzzwcUGaOodV8q3h{(Yc=7m%xbq-Tt93Vfovv0c2b|(0>mQL^btTP%
zjT}tBpuk1ZE+D4wH++oogve{745g8n=v(L_(Mq2LzY4MjML)E6SlQZwMuWFY`pcQd
z2Q7=CoesB(SlB9*m&yHWy4u%eW5yk92<9J+pa!?sos1^y-Fp*zIPMQh%X26#AH(x1
z+}#>&A0l%XunFX2X%SttXGNjCBx??eg4e3j?Ym10-))yfy&>{r^EO}s`N>QC^1JX%
z@Q+0roAmc^nL?kfXI{w4vj}pNnX=76va`kre_4rOfd9+MNveHMzVY+vVQ%JZz6X+h
zgSH71N?Q6Q(~>vfXr>3GuD5Uj*U#(stg49DBv}j4QO6zPmiDEWzA{R|8wu~A5D#oz
zYOLn}ApX|}*_o|m?imgG{1Dy_&le>(BJOHv51lyGLJ#2LGCtsVSqx$qb*d1d;?AD$
zrS7JBF*)R4-LjUII&h{XP2B6MhPDk=EzCAX4-HSP;WCEeP&n)BsR3IRYwN&SW>jWY
zM|eXB`}`JECv1V?s0YtDZaqA;w)-wcHMLN2eOvZ4ACZ{v!lK=tLKscbqR+t}z|^uw
zkS)J~^Qj1K(eERALUi1IjQ%XiqVA9m8ei{z!Nyw?wvS)yHDLp;e%+yXB3iUwgyO<Z
zi0`vN+u4lU`bwSKIkCjO1@>@L;a>JPmA?G!*;SeB534hnqEg+Mu;^FY{OUBeI*wBw
z=I*x4S5&ya_!~o<|JZ8x^X}L?DAMO{VXI!_SXH?@{-9OvQeO!vAi<n!M$EMvBqo~m
zpxhnF)0|ct$(8PW9(3a1wwdrP^OEuHSWw{s4!EJ~gkBm>ft_WTDazL(dlJZj4!1^b
z;V>^o8fR%QKTgL;J2+Ff^pc&Mas>6NTb629g-uyKEWPA7_t9T51F-nQ<WlFcGf5xK
z_fIz;4d>xGAUz{(Lzu@I@AWn?N~>5@UkO)OL7?9ArVf6F#er~%JC{N1o_XF>^o4p!
zZxk_|jf!)5idv)b46pSge!eVu=5*N~F`Ik8`9y|iya2X!>qLl)b3-SN(PO#mCqQQ>
z*88W=Z?`8*EseF_S36QlxYFQxcC;J0sh6``tv)yKZ<gPRzGKd48spaTLHEu6y-9GO
zII6-MD5{&W!+h-C(pPfFgq!(;u6i*hA{(A9i#g26SXq6EJDe}N-BhECZ29}`hT<o#
zG!!4)=@!gLko>VC_I2LWlilU2iZ~-)Dy0Ipc`_+Y_`7?_de;Z!YI*a_`FVdF+45s{
zhgGQPXxyQLJ6Df7qrUm8%v7s`x)wq=N%yehw9Rk&o>$fr9fTm@^!n`Tplz#CtoIzu
z)v)w~wpFDt2%Z-P!_KZvj#V5{)mXavJbYElYJ~6HVY;qF6rH@PZN(RC6<RT}pBve4
z)szuy0ZX;$eQ4e&lj^X;p4xN{a8d9_9m9HvehwvC3dS&6$O-Z-)Y&E`ohu*zZ!TS<
z4C%n`YK(F#@a0)c+A3wH=C;M9Q?v=7rP|`?`|-r?0$+L|cmxE~U!RQJ2^aea9cxqV
zgn||i=Nu*7%t;o<nJHt5S)97s&ZC##qeaKm1W%KFcN@beo`|*u#bh+ku-Uz4dy09$
zsqLko33eV%35-(rH3)b?_)YkGDQ%7+)xc@v^P2}}6xL#%;VE<@e$9ByMGT}@@O;v$
zRR3?Tk}K!ynE~^ga+$p_Pr+i$+m(rcpB{BX#x^go36b0kEig5ng)Oy+h53kus%TtZ
zKOjt8%QqVys0M_CSEFl1BLNchVqD5j)bVg+%SO$iTALjd<R-EQnBj7(Py!;YgSjIG
zj@;2#5mUgudn<gT?z41i6!9%^aeTWxdWh;``L0<J)18=Gn|MZIodcF!Qo9M>HiEZX
z2X$vxHBZn2zm5Vh#C+cn^DPi_L4Yr}9ruZWs<HHaAtXj4CzRl7s6l*jP-Vng1GjK<
z3y8T)7|<IrEq?qac&UYP=vip_0zrPMCq_%^j_XS5j?vOnLi9C*ZL1pR@$$v|bP>Fq
zrwvvXIfj|xiJQmE{Dd%%mrMvVW_U2X+>Vt<!^;>Yd8;ra9wh-$rgU9H+gqiARM)Y-
z)!|mD`;KKA?R~ckKswfNa)`&tJpcJW;$?ahycF$JxRY;-@lteRTO_(P&FhVq=jZVf
z=H7Bf5n5{JjpX2egO_6(WLOvHX{n7^#O`swQRTU#UtI!z9{(rq{p2nPpECSZxZ*fI
z{i#yJ%*coW8+094slnn}8(-^nO%3Rq>VI5SYQS-Wh;@G1pD8dLfz*PH{PYFH&3z-r
zs+iP(5u@8ytY}+YF=fQqST?lXJ)HtdoBPJ{NV>9H1Npd<rt|aU??s0}cGhCX-wkIp
z7xlsVS(vX%wS7)P{|jb+;`nYI-^t`=Dicr|9t>=(V28@3EY6rG-~W(dbAtVd|5mUY
zqmJ8KEYF_+q{H8)oolEefu9K>JDL%Fu}BWtI>0+Yctnk>J%;g#&Azt0Ys;oEr@5*A
zgjGTk<;6t{x}@R+&v(xPW$6#n>erv_Zv7p@lD&bILFB{@Q@Nzt_gM}kvRAB?Vt_^M
z19vm+YSVe1jl7Y(nLpJp_AKJmPKJz}4B4yfQ<BDkJyw3CY>!}8Wx1_BldM7pGwr9^
zt5nOdqxWTdUGsOi*=Hg*<GA^zQoiQr7Q_uv(eJ6~Y`sSf)l+mJ^HLt+X5B2$q0eFO
zn^J~6UBKLZg<6{M%SDP`T1al-SzIc~mS-Tn?M<k$KVbc$FNI|Wuvvk<9kMs|2To~i
z-ea@Cdd!?+I%?+!;AA?nc3y>v53AFv)YUTmn$!O&Ixd7YsJ{cZ3?>NKoKOSjrxj1A
zZ_|MHaH89Rgt8sjQ*i)SjN{K-bvRn=RX;*TwTv)}4zc7bQ#)&Ao*AeOYhDA$^B3EN
z_Nq8qh3iC;P=r`n#Z~(w=G<4Qzx!XN4|l9?If*d4*m`goEt;>&8%XYQzKHj4R)hJT
zR;1eTDC+6H-|L;WL}`iwSiI<Quz2tv8LYaeu=+fO_j-En+kK)Q@uLFq2_KU6#&JRR
zkX{Hr2K_IGH-OghnUS4^Mt~;cEz$B%Nefl+W;R9L9Gd?IcyWgvzzb|Lxgo!z6<Vsi
z!59jSmS?cq{R6B!ZY%LEtjiRz&^<@Lw6s|tuP}Z9ftT|!ekU%p6UtDcY!0fS8XD9&
z;y+shIAJrWdo|Vm29;}6=IIA}iOw{V9FfIM>bhno#4RJ2rpSY&_SCCGLrE!F)R(R(
z75A2MH$jb2%S3qbB=-oKti4{$8iX#=j}%YyCO%G5s^wRQ+C*KtgTO}CjLB1es>2TR
zX<INZzuK<(gJ4$C@)Pgd|BXKg3PT1xsYc@ewZI(=%0%z~Tdcy{L-Jij(D>e=0jYNa
zm4{%sGTPUp5OiohYt>9xnCnDiNlxq%j7zH+skDEF<O*JCtTIBHEeu4-;gUm}4#W!j
zASvhvVpoPG-^$l|4a9=NKy0hQ`_h3(wO<3ay6&5Rz|V{1=rheMwX7>`hHrl0{v(JP
zMlfFJvgikk%69RC84+@jcu{<x3?}XbB>6xHztGEb_&jR$g?sqg*+5hJ7Rv0t-RMg;
zGhgoyRPXn{tlmQm%)UJL`R}O$Hztv^#v?(|C>g(nn;F0NXws%FxxxKWz?j7@Dp?Nh
zjjt=Y=J}22SsY$=qRo+X+r*O6D-U$#n8!E9&(m0`gpKvaPfz{Yv>;xv5gYLP7(Cf`
z$i`{d3<rQ%giL#ZObLR?qN}uS;ISnHyLr&&5lnG~3kdcTp7LPaB7%L->iaTEPqn{E
zlie>gKreD<<713#`6A!eS49j)$}!_Q60CLU1f#^bcK?#@EIoAd-I>*kUI-ym=*|`y
zm#t@gDZRkB9{F7X*AvEN=ZtU6xSHWro{eqHw4%2`Rrpdd-{@XZ5E-I_-MzW|&*}!W
zaK??QRa|*9G<cHHLOu3_;<hC_Dqgu^eUE2-r~FoEF=WVMm1(T+Ft~6uVyRePG2MJA
z-+R-OGWlH_MMr&9yABg8rs(Jl@wz-ce?xtkM(!>4;So{qe?_;`1iX#w>z?V}7Kk9(
z6PM7a3;5B)6s}WG4sw?w7ujPt+|48oSnCxPB`w<&`~%#XAQ*O$g#Sa>ri`M?_XYkX
zi;k-(bw8LY`Y;`vg55ZECX`8~x!(QWIMpyrNvUa_Q$|#@ced=%HhDUqni^*29l`5j
z9KEm!_I}0rD8E;_71r{vAUk`hDBx>W=4|QodKE4z1UhzSGR{mGkbc9uuVX)j>9;T=
zOeRIzbFGw%^2tAzOUG4}l+qV=Pn%*7t(`SO_!^n_balXDUzPi(C=FkcWP!9uI6u#q
zywcifte@oNHi4V;s+w2T++rKaznW{WR0+siEkRY~n&_=uNWKpu*=J<;u3_g{1^GwW
z@6254-`0w?tq=|)ADQ?k9(EVNP=|W;w_VkjxNdNyn@A9`Ja;eY`JaX7$Mt+&;rSt+
zqrHF!NgAg+^n769`S*Gr!n2!1^<NI}UD#E+S$NCecVl=TYXtlMF}(ltYY*>FO&&2!
zc>sSoywTrQy79lk%B+d39{TXG5%AA00N>+x_oGwYg^X}9ywB8g5xh^}xftHV^jrk*
zfqFK0_oqhhzu0zF6>a#OCAZuNCU-I%C*vDrF9pA@s&E(oiuOs<`hzxIX0JeF8zG&v
z`Ej$iFLcjbM?>bsQ{gr4&kQLxQ{&SRGQ0Fj@L7>jdTNmdpSPEaFMQ1LG07Sb^mj}V
z#kJQ25GzDSg)9tSQsL&)56<#PwSRpZQOJnO)guT~)WHrIy3$_L3Rp9_hwbY6LYgoZ
zIgna9(O;O~wH{S-APbMU2a94x(7y-!o}VIk2D9Qt?$5tuJ?j}pCRoz~gImU`sT+O}
z0#Pvdn`$wGFe<d&*8?S%`Snth-%Re-nn8LI`woY<)@YZVrnTE?w4a*_5H&^61|xf;
zNzzJpb}eV0&f1a2%W#jku?|$#i(7>r<gHXGS_ug6tSQkw3j@R<YhNHJgxADr0q?Kz
zd2M~*nwko0j9(<s`heC9iYyfEK118uT~b&7hUx=Ar{W(JKSHi;Pcz(DKoaEsP$Mgz
zZ^IvIR_H!%!#sURy*|yiL3yKfpiEwG_hXQ{ul#|_OU=Ff(XXh8-a{6!DQ0kI>%<a`
zP@r8@?0=wo8zBt}BUE~=jZp6Bp%fIX8B(W<AE@8x)H%kY<8<SL3=H4T6$YaXjn>Z?
zUVEg3(Suc-*NyotBWK9$ke&;1aAv~Y{v)EaX`Z{adY&Do(fyqD63x5D(lK#kHvaP=
zAli+&nL8MMASooo+*=W^aznnV^qokz#D}*h5j|rp-UFJSrP@!|=c;#&O+qP^C4ol4
zgng|6XKA*QBs5u}E0MhE$}%Kv(eTx^+y32D`^S|2Aj775529Y>y*;N<+cM@nNFTR^
zIc98#k*Bc8B>ZtZ0R4^3Trm>K@8BGDGsYp@tlWMyB2N>bZzds#7<HQBMi?ouwxtFc
z{eZsl(V(Q%3W+yr$G|E0b=0cMXbyjbtTNeqJVoVL0qx?2UX5n++S{r24aO_3x1uu&
zH4u^~dwpCmRF$1JBd&vpTHNWR(xZZ`Cx#%`?rF+G5N$6K=FJLKz#F3qd$Sg7k+a3p
z%Nc>}h1zr4jJaf`d-WO(#W+S4evjP4_XK3b^VIfAJq<+NS(7PE4wSa4m1-|TOA>bY
z)h{C7e7rRYh8b+^ayMykh3H50Q@)N)YrRe5M+n8iS6-OAN6%CPXgpso6Tp%6qlL?(
zJ&-y^_wk8E#1VG*sQ46#xd>oUYbLyFraBEr55f-PLTD#4M7ZsIdlVa+jZi9kTvE1L
zmMeewQdKc+hQ1FwY(R4z@@ipmdu)*FSY^|m#&O&(_qXG@o$fOLtfj$rC0m#2TNNS8
z?u@OPPs5H=4YN$W3Rz5gtYlP~%}7{SN-8qEYU^acm9cz(GD;&}!Tqi++M{sM0*YL#
zBKvpDN=h!n;Um{kFR0|UJ4}TWj)0eZ^(K*WRf5IFBAm`eOoM$+#`bhj1K3Zwzk<9m
zd-=WHL-XOg?gt=<2JN;*!huuRbAvX&3pD%uQUPM68x?0b!!iJJ$-UT;bAhqTc=LOl
zHY!eI;PUzQiPJ_Gr3wGF1FPbZ8|X$lJj7kZfIYAS4`v|0@8q#^Nb1C@d~y|2s51v?
z@mdZh9|w1^T#@QOs-FL&`9D^@?-VPAYDUzib|$_KVVdwXNcBIB&BCrvs{c8)IHiFj
zqpHbL&vj_Hbg2vHalCWe>lOW$wk_^6<?5+a?!J$9X%cz_i+3D}Lb2mE5z*7b-XgkW
ziWkwc=&ZTd*}x>OpXR%RDho}l&<lm-6*;`XU}iXI($JIGPy~R6<HHGvQ*=m%32Jr2
z9BBcG{?j`Az*PGhFwuP%^3<SdU%qygRX62Y=sLD5ILY|c(mvXM1aTtSUcJ~$wnsDs
zDF0yd(btjY&iRg%B9<-#MRqqE+r)aguveoR*%@n%%t955^f_zoo;HSL<>;dQO@B_#
zFDkP)#pf42m+Dx_@Y*?HLGFB-)`%${$CZv*<*-Q5uf$!Ml|f^Hwc5|1@wo+M%H2rb
zaGoandSuG}zW!6f6@eQF(D6$wy>uJ8h*bNRF&bIy(0{VCMjK^%A*GVg^N?B+XSp92
z?<x2(`L(CuqJ^yEzTZ3y9}uL|JMN1c0TH4&*;OD0L*;L~!<PW6wuS5~cwg=tg&Ja%
z|2Sz!t8GVEZv)V=hqxoUL_o9hvzS!JJA&4v1yU}1EpykC`9iisf4Q<&I~fpcMp>J=
zr<Aq*0c@<S{T1>RpI>8qe#;`)L_YG&SZ6HlOtC}SC6YeK-DB@5Pr|Um;LLn-rwha*
zVs{Ud#FxEAsGgCXQnBbyqMAs**h0tT!;3S^8uyK>wGy=>KEw~3$dsgh39Dn{;P<0H
z<MWCg#R8;@a99WfSoJJo+$KuPKszE($U`bLS~KUtQJmijF7@oY?V?WH_kuczvE>{i
zxu)z7DWw<Lr8;h4@)Z4zAL@hi5F~nlS6-uIKF!Y?caUTeTZoPD9VNugiB85cX>?%}
zX?lRW5w?Jc5i=K43$mUycvXNnB-W51H(Ssrcv&_1N@AbS+XQC(TNQF{RHf???qid!
z)Go+>LPg$iG_Z`jM0w_%C0Jl;atJ=M`&<Tk!+{-W1>qV@^vV)`U5AjU!-kn|;DCJB
zDzXycM;HCsCf%1Pn*cuuLQ>?~H?&EshG$`%4&z89FsYz>_e7u0?wk&B79;Oa#+CCl
zD4;1^)090j4Has0xrWIr(u5-rdX8aa;;D`)(zAYUd~^*y3+Y@Lhgb~4hqdK40B0?P
zUsb2WuMslW9&zn#8(zY>Cy-iGc+|`6i0JMp%olS<zs4-x-3mVu+UzS$HCMh+Gk4Z?
zbm=P3askkA{PLgqlu2Cl$IC0@+b(;@mWkmcURHR2Nqp;`rW?@1y7N@@ki$u)hHHKT
zoBJAw82yb6t=NCApmWKDP&~EcAG9bsdTxw2rqD1*#AumnEl?Z$K0|8{`u7xWTs!?S
zmV6q77D)3!ZIloVF!PL81@-{4j28(`(8q4cc>jKaTc|tulK<l2I5UXj?%+*y;_3v?
z^Yk0H-%E>O2&u3l)$vE5gh=I~u_8K~@J>^`cwtccuwgF|Ef$r^+gp%-(ypS<pd|4J
zg!(<E{-(oaoWfKUtp^;?ovpP-KPGU1|1M!e!k4Ox)p#aR%>8Dn%YITDgny`+uE%6j
zTOv?<K6#ISqe<-=H$^9SFazmS=G;zOFBWDi+K-cePbSakP=qc2tmR6L=f%05K7ew`
zua;a({-`hZ%sjrqFDAe*9yY~13N+@%5Ax|!dZT;u=_dMu+#dHlu1L0`&KoqoFctSJ
zQD|&B(9A~Y`{y~NnV`-MIsb9;;Sc#Y@(Gc);+@!D^doAR3^y|VtI=V&QXONMdPWbx
zMTz}qRL?Odv_*f~5?mXtBQD)kP4LtJ3W7|YU!<mZR4hhAcj^ZkUEW!2oBYgGs-wq0
zCZu`16U!R!PNG?QIl%>X=aJ40(*r_wY;-wM-=;D@VO(QTm5i%5Eoj=ZouFRZDluWk
zibN*aIL+LJQ@0A^RQgzcoZfzgzTf>Y_9bbXs5I~|ap(XG><W4t3?rr@TE|nu82F3n
zQG*m&_%?gJhKM9Nr;J5=d1^HfwVBct-UXbH)M#Sn2EMcLzd@YSx0Y|%bGN86`Yt2|
zUL&qlqI?}&xt6$rli&?&L3)oTZZ|#uyYT!KJ<F2)|FHMw@l{sW{(pi*qe4$mQR+~S
z8Y?&k6-`7m43Tp*QR+~^DFg@*g(Q*_#5zTiD5uBM%e~cVTWz_mwYFNdEmx^p4Io0b
zRm2IkDs`yOW3=D|IFaA`v-Uni0uFt>?(6&e=bl%dJkOrjUVE*z*Is+_;h$3Z@VcxU
zNwe<?vKeQP+d#kb-Ssq%Z$}!j=MihpYVLMsz_N|TT%hxtQ)N2zF+J)PVzd5m+Ev2D
znb;*V?K!bed(NLFbf`V&*_Ut6i{wa+3}*s_>pz>}hsBN`?#S}9>2kFyL}rN2C%}%p
zzJ}!66NDHqJokW7e?7_f>_r)1AJ<pP1N)7II2eJVZ%7gbcM%x5w-aCDpcc2U>&JS#
zd+kC`cGZ`(ulsz*)eFoS?j;$C{gXO`+hygY>+)}-kz(m9%I)kCcFU`!DTw`8j3riL
zu8?zO<q-dl>K)XXSejW9uAy}^`aZo`xY$&m4n+dvqXx~SKYNDGMgrk5;?l++&9L5P
zqh2eE9^fU`ra!yW`TU-jC0|)|m;YR8VZJ~6O)mU4{}~issY(n!c(V0pQ}L$o2QLKD
z8LG1mXkfn_M>vylJjv;g);-6$c#+ZL1O&Y?3=#rv8nf-5|ANbV_xuliFWd7QbJZk|
zekQhE=Q>J=rL7>$E#a-Ent6Prwv(vp)kSug1OqDvEE5hK#RtFO1j&C>Wc|EB<%+~_
zurE&~3vh%h#Wd+rwM)Ur9#n(xGxWW)`yQ|Fp3AVH90#(3!F;hECj7(yxOd9lE5al1
z1(QGIU-v&0{B!eO8IHh5?k%|KIT*?fyVVRj;fePtWJUO&KF0Tm!MtfW%e$4AQr_a<
z$6Ea5VZDFf?B6l}zQ{^k9(LdkM=Wuf-@4en@AdChyu+gj4Ac5|luYTA`L0D@9zIQ3
z8G6-zC+=eR%V5}?>Th62Nkm?rU}rjM=}rEgi;mKAsMCz;G}>!jAU!f}bFd#GEsm)_
zp4`DEy}4O67%0Ewc!tSMLuyhpSc(58CMC#&^YA8-uzR13Tzy?)0=0xO8w>Q`K|d4`
zv9@2M!X1N0T(Ep(_H5;Rhbrcux)M+7%#sOGW6+}L-RN+tlZ#8+lo~2i->6@3#x+tR
zTtCl>qTp%FG1V#8ajBD<nkhfsVPlzi#R_+h)P*7t`ks6{$a4&oC6tsq(6H=SC}vAb
zr1N;bg6%~<z9OAkC7RVYYEno12~A(DIptx=`G0+In++Z!H!f>?v7lp3Vy{09bm6CD
z!Xr0!?JZ09^-EbbJART*T+HJiPU=}i0&0srKp*Yvw(PiS^n&q|BKIB=qc)2a2x>4I
zIM%A{;0!xWL4?mh5w4%AZ2SC*NXG@}<a`~-n4d4NxWur)RBJhp^|Oa^=sT;Qz6JdW
z^B|pnLg4<p`^k+LcA#F20boShrKs#72ir`+CO9T*STZqK#;{YG!)o*9z~1#i(~I&d
z8bk_fMox$l%x#L1-<H>sRBE3a3_U6x@o17tmymEn2sT+3rt|&eIc55w(>#-JtL<-m
z0x$IMC5nu>_a001plR^I{d3jcK0fH{QlQyoCnN0?;>zf7!*2^Y$%hy~o`77MLlr{l
zqLiR#n#z07Rhek(vRM~dG+AU{B2MJqi<q2VUZ{rZxPeHt$z@I>R1hwVO1m(gjHk}#
zsO<4kZTx1XadpMI$Tg?qFKdvlbx0lE&$bhufS+)^Pz8eM?bVTIMxZP(^#coa?blq3
zW!GKSogOjk2^asiRwPCqP@NY+)72xVar|QELP;(ZGzi4Hj{a-a$TpSLnXoXASoKfw
zR4rq{@g?z!+Myir1UN_q2=nFYVQ;dJ)0Rs^UJH%|2vZvFgro&=|4U7{aDMTM>WbGR
z9b<M@EnlOLcJzzX#jx|m>+4^Sr3X+BBy4uac(MtTBk(d%A3sDQrYN|29+kWgQ8#^b
za{M`<wOR7zXm)&{kq>_TI~=gnalY7M<lwod%Q43sMZ<6;2F6oIFiNhCbRGx!KOCiI
z!2~jlr}i)-LVBNFMj|seMg~=42uISDK&1~)QBOR6GS><fqh(-PG%l{>T@Z|+#=>N!
zH&}EGlXOpyc=0g=O#LNp3^7aH0gNA05~u+~@0!Fh#QNL)!rSw~--(D&o@tXu|AFKo
z>_NhU<ph{#Ka*u=md1!SS*rjlgBivG9Mu+Mf4H=k`?Zr7evWZWWKaRra#RLK*q5hc
z7<8?m;3u$4#JQ_+AfMLBGyWhnqu+^`hqCf8){eanT)s<;(d{c37LWLNLLr??hQF(z
ziuAw}egRRI5J$XT{0-gKyG~>~1Sw`3={0|+ZW*$jKm`?X{TvA?H|EfUqdEp-UO#K3
z^H*gYbAE2tNQ#(kih^kczQQ-#yTs-_5f>JHWhIoUsMlL?&`wzy;ouIfAMORo)<R(q
zLTXZ2L^cHjT1cjQF0492pj}4rZEGnf9Q{~#e^n;cLM1i@&#ADjQ@sI5KK6$f6T9M8
zYm!LEuL;P^>ka29WpUIRVqjJmqb4fa$_t?M^oZSj;F~7UG~2K~c)?`Th>ww$az2JL
zZ#`7%+<A7KbW1;GyVNr<bt*D_%t!wz(L=fh-_L9<vF09IlYEms*+nO}Uw&|LL1JiD
zP@y9DOukDdFeD7T{^V3*XmL=5hXhib)8fOYFl1!(8Hr7G>o-~3xc<(zsKrLA2aHr*
zZ~Y;*_d?x&d+jv99<$(3bR8F0B%-uq9vwHdupr!lF}B$Qtmo|twr^io$P(sOmJvld
zH<LDUFDD|b%MdHnJMvWKeus5Iv)BCGsF33sqGT9M*-6%3@wnSl#|5YZTkj)aM>z4z
zsPs~b`C=-~3iYo`s4q74CDa9?LAs?rgvw+GMv34;Lc=G`JTVR)-8g<yKTfade1mg;
zsZ1<28v|ix6raI^?1j}yr(ESG;G@l=S`Gcp$`jnPgZOw;aMK0K=X%G?@Rx(b_Zo+I
zaOGKDu|Cp~5Kzy;0O5sv*|3B8k2pOL;}({cAj@|Oo&{*{mC-O*?+c=}>O^&@jC4*C
zr|Se`cl6nO&%g_5A=wwS%e&G1oW7ek9dNz6)2knekwLHN0PsUUG!gCpW>XHrKSDmP
zf07QMoQMBKR*HX(mQjuItBD9lc_Do)_MB8DORTNyiFEvrRnWSh{v0F`>HLB7DA_os
zB<k%K2>)iX;)1WBMD<IVIq}h;#RQA(SMJz!x3SMmN$uuX#n_pVj=w`xLDPBYfD_0w
z$IrnjG*TGN+Rd}08Og;Edv>-yp77Emeswe0KrsBC%7nLJF)%w8?EzDb47z6t=~|2z
z>3Hle;Lw3akq)<{)wNAH7x9p>N9zzmXS&M}Q-+X&b+dcZPjitt>Tp%wcBzV^Zbo7R
z_fhvR<EU#yxL+vuJ;Bg#n4ov_Cz~n7b=ntFLa+Igioas4I*v`gsyA~|oa+DGtlb2u
zWoWl~@|kKVb&gnRiiZ5reNPUSnA)46Q`3a&nY~g{)Zl#0S7|wIqG<gel(wU^jr@X3
zP4(@i4S$>DdD?ItMR^P8b=WQYXv4|nU!o1)d68&pTiWpHd2&R<4C^>e8!pddS%pN!
zXcqD<g=Dnh_a@;@)~kh-UfS@cMnyv#)`{AW5lx~#d>hjV{4tMSKxC|8*N$4Z$An>6
zz=x&-(~wAbD~{lYBr_cjjmGOSZoLk3{*y)@IeyaZh=6&v`F5@B*BES5m2_oYtshn=
zzXy_Cd&E=6W?>U0*gly&?MAJ$mI~;X(R6}ei}%tae*Sy468k@#^OxS4#2Nkz3zYE*
zby17%qd;TNZ4G#SghkuiLdw-&+iEzO`(jFil@JY3YGAp*5RemsA5L@`mIq1u@<Wiz
z<xs+KAP|_MW{7oksuQMdB%L?fq6QhVYrjXid$K#-U{b*u5GKSJ0hH&#L13`63Iqw;
z<wLRYY=p_R2pPo7OvI%#7>Ac*C}Lpzz}--F%Z0+>sJrz&!+rl!-{-pT8})sf`%dY5
zEZ@PEk`U=p_x%KqBNd3%V<?;P^giF-E5l~*{+)l{$2-)Hy>OlPvCY7wDEy65E)Nf~
z_locl-r*ZQ(z8CW)W47M@0fqj;2rMjBhNF>72#6vUgRUa>fi7A_jbQ^CGO8VJi<E^
zIjb+{okE1A#ya5qGZN{l@Kc8jUrBF(C?<<2G|{l(QK7eJ1n6QKr)a+}!fCt7cHA;#
ztoZ4oKUB(aIPiz1A`f(T=lkJ)(CZ-9iQ&`;YL#2O!XCdiR$5Ues^ZPQ$c|EJMpBQ(
zsa#ysQCdulV1gfs4-weueMa7i-#cdkTWZ9c<LKVF7htUtrALgvix)lFWXlx4c>DH+
zw)eK56g1Urfr}jMHG@8dB?;<Zj@?g1a^}Bah88DF1}>BXde&P%5p!|SF_N|Bu}NdJ
zp_+qo5V}~E2R<}PB*|&>#gbAcn36Fp83XVA9bjfMOBTCLRh2V?&zDKi9{3)?qnD_F
zTqN|Ida@a~)A7RR;O!n%BdiZnX1qtB3M}a=W;W`0V;_O+8!hMkXY+Qzd%LMxKtEN~
zH(58B%(PW-;WIQG<`?kf%3xCWM?QC@je*L%g8xfF@-lRzg&Dp`Yz+_Ia^-P@1L=bw
zPj_R_a<mG8Y?<aj{)sQk(&xN?=)L>Y`#SG!rRHLH$~#^3TPmiecfh4b9FeIg^%uDW
zh6lHz6!OT>M*FIMkcR>lX)|v}J9x?wyfw|(%xLDQeI4!$F44@^v@)^6(+YI|lB1Oj
zkqkWa7vibGKe|J?h*Z3JD5;HiY)ykkUg%O3zt9is(_e6lHr!yq6yo*JNx$QaPIlJd
zeEQpJ!>x$qh`lLgYa*Fx-d{x|kN(zGRP7Q}t=XDLezTX$eH%n_jY`P2!`C5_1Sp0j
zJAWd{wl$Fq_BH84Bu{t{`Vh&D-n$QxbjdqibORO3Cz9)ZMWv9a{k0||OBp&=Lc}3Y
z(k}Z?UNDkI7m6!;LY7wK2p*V{qm`elz>Iv!6DgXin;Z<s&?_;rva%8)Blm$#7pUcn
z7JP^Rhj!MP%xtTfR7s=TlEHM*TfcGgv|DEbNf<pMQn3*br+2w^fmJhu8y-?lei<n=
z)M@Ub!x81Z$VdkC^uXtjHBzcv0{nY%2bb3I2&K}HE}H;oThq|qUyFw3-|i4#G*q~H
zYZ|&`PnY{PXz0fZ`nPDP4AhH;o<gCM5@wmQ6U_wpA5U{7^`W5aX(CngdLP_}Wa=Hs
zoK8LRN#-J7FKMbG1BU)vlZ-rrJ16JJA(l@L+Y%im!9FAU(8S<VOkfnf;c3FQ>u$)=
z#G^Fd%fEIs@u_ISBn`$wx5A3!o<tPf!v;~bVNrv;ew^)myex4<@Y)C?f}h?C)Vu%F
zsmE8I>X5b?V#w<Qnyl5nN`Q3UMk1)+8o$4p(0lhX(Qmrkx6$}}E9l>9{G&j$8via6
zAQ%aQr8O@5J}o|Hh->j*5UdXNCyEARVO*w(Ie%cEn0jCUpWs_}B5#z8n^m9o?fS)1
zC>k)mbdAXbAs{qEF%v1_Viuk4Yu@ZLn5PWj|Czk?^IcDyORSIuK7>3ha=K_gpT|N%
zL}EAbwiPf+l<T^b_;#PzNh(DQMqD7W)3`%=&K|;MMh<O@@S?%3NA@MWKa4SI*_nAT
z$stF0bX_<6iaBLu5@dxI#3`PTnt+6uvh)`<Te%V4x%VlX2TO$uq6DXS_XO`AY3`yk
z=@3UR!M>_U8pS%IJpU*o%IS-#)77s#q6|+V($*5``@75gtB7*LFI9pk$|enN`=~z4
zEgP?;hyqbE*uZ&2Ve9TeZ7o>U{Ex8%deZL|`QIYb>&|y%`uWe5mB@5YU!4q@X7+l%
zuO_6LuCUy#S}%J4jHJrMUnc)_(Z1ISBu}MK?MJ@C_keHF(GuRGb5FosI6VP3LwpJ)
zlOOp+t9_!i@`ln@@z&21;5wWnR!HDO$ipJ1izfR#HV~qMH}e(&7l6Dz1YC@lWouon
zMNAhR>C>0_^yR!s=ZIX6V8Xf7I7{U3@1gwjlzD+AB<ZJU(cs}D`VjfR-*L!1^*yQC
z5xK3d-<*@KoSZXw@h?aY0UI0{0UH(N=ZO5<o~Tt<5&87Rj_6l=_jkSf9`8QM+(mcO
zjf~c6X(h@L{XB}I;NLUE53XYc+P0|Rne#ANF-H4)jKp6_^`9(K5uWNVU8O90i{jZV
z$yYJk5XCPl=-;C8+s|<{ey{prqw!+|B|Wmyxa*NQ{~k|uz2CI=`e2YnD!L%4@-hSr
z&?U5?2xtgz2)g3Gdl7IHUr)gEAU+qV=viOkGM~0wX`zRqy!G=0Sm_cgB<4fN!y>1P
ze!hq_ls|zGl|PZU$$Ta1ErDnH#Ev*EV!Ei)r>~^Zl|IHhOTcmj|1mM2fS>wm0^V{c
zP1j3hJibPhR#e2H3~q!iy%C*YR|@x1nw=&!Anw6Z0Ro|IOG?*!0##i_z`y#vvW4iq
z`v&hW@$OD@7hOpwwG9GZd6*G!8QNy>_{*ZUoEY=t*AJm8(eK_TQQ%k7?{Pm9Se}0W
zv_d)drr&|u|Fv!U-Ra+^-{5RVzfb;D^t;u7^_#wjFk;RPLEj(jK)6RJ%6UKTy%+ZO
zzE$4oqKmKLl_mD{h-to}&BPYX%;TLWt=n)Ku`e!dD=?deB9PCUx9|c%Dn;pTk~dVn
zfVY00UKimcy+UsHA<(-;P8Z$n^H2qp#}eM6_bw&sP4BCGVn^?a7%V?awCv^&b`XYu
zW)&ryT_u*jzO+jY3f5acTj=iO@<Hqu&Le9P@~21!>h)(X8$uNBej+1kKMu<1A_4v*
z09j)mr-!(_bL4G(Lst7;bC*ckug~z}76mD|Ki?mc7wTaFOB~!{fkj*Bi?Z5@Q%!tE
z>49%^06(C#o2kJD8zsSWvd}|0hJYL`G<hmrts-*XYt7qb_{Bz>V}2^QJP-U2b|lXO
zt_&$7B}B-OtJhpSx819td>P(l4e%vKn>WsMJaF2!dEi;!U-aRDyW|ay4JIe&qd~<O
z2bYzZt93sgcY#0=sq)rOh#wm4#;xZvovf^^G|%+l`NyjLie6#`LslP!23$fnKW3zm
z9ypT|m9z*#8L_VdBg^1@P%neZ7lgDstt1<QtJsCgo}aB!`qv<VdKQZr4?94euui?N
zcstUuaRB}!2Olw9%Q!+D8!I)T)-w=q@=$x~$DG=O(n)9pYhre#>}?|6vBjTnaDDdB
z(JIByhiM9Yhi}NEs<>LmG`+1%M;0xo{7A>kasY)ZuW9S@s{538C$dYdB(;B%E024T
z?)q=4|NBb#`aZU4rY>X0(^Te)E-IdWV8O%F2X0?EJvnxwW=lJ7rHIIVRYbaiNcBXT
zofoM}krKNEw|!T&<oMk4>FSLi$TNr9TMerl$1-c$@u^Uk8p}cx=3g2`=>qLv_=4od
zBUtMCV@OSe-310M@Z_Ip`jG{vi`|N=^cW8K-rlB=>m%wmuucfuFIk%%jF)z&FOt{0
zA_#ri`G;br^mRUy>-~x@1})WW;M1gsC?pnC3=>&6E3pQI6=w(@w;q2lK*=?yC+r*z
zH;S(~m*Xa0C_0lx41p&GGyG*#9&ZYL1tF<HYNv6$wEw+NbV;MZE_~TayWvoS&W9dk
zRKbZn!KM=w=|PX7tPQx>N_Qme>3w4GxW(0EDmT46Bu5@^1%H;6KEqS8V!w*65DYiY
zD!jn!5T2P3v}*}H_}eDmx@BZA6Xi)|!NzA9iluHfPKu>;2V5Q}Swp=69qDXTvC`T@
zS>ljF)*3JUWM^PveH1!Eq$7>P(e_W}-J6%1#XEVtwAu*8@zRSljOo9l)YgvRtl+(%
zEEVRM>2oWrXs#8u0f)iiO8m~&C2kS-<dt{<C1xfIk~dn3aMMk6(!o>;&TvyKdC|7H
z>0XK$tu<m3<B$g{UAeiehJQJh8Vv~=Q|%Uf2fDLp!47~CCjgf6t*c#w8GI8^>3Hi#
z)xdZQA#$PkK)f|yJd!$W7qG60wBx=ba?WF~jvpF(X?<p8A0D&A_pcVmGTZHV%#eDL
z*cG;OJZ8M5<Yi(o8kvc_1dO!dz}}3s;WU-(80qsL<zsd$Mmpc*oH&Ss1a5GYkYgm@
zPqF1;EzA|%bh_iBeN<!NHF$2M`-%pC<;%F}0hXzWi+;*mO^R(3^kjMG@2VteOM;(R
zTDRIFFG7otFf_Q72<TwhNrgwQ7c!i@2>x2FIy#zcRwXiO52V~hk@^{j1Y?*H%VRzD
zVILqn_R_3Kdhi<zP35(&?NrRY0?ax&BAi8W+3pQpp52p0_exbu54@YRu++gRD$`Me
z&%RXvoTTZdNAaH-oN8u!_6`S&j}shQ%@^Hb6y!ktV%6h;|5CnQ^*HW+wX&(-S=D2%
zN3xpC^o$&$FH=w!drSp%2_s)NU(^6fB_wx%PF?eEsvrr#_t7@i8Sq<aSuc2RD<}uZ
zf8m|qj644@uNjL@$u;A9O8<q;c-g*NHRGqWNa^p?j04X<%r#@ss~MLP;bw4{ZAKJU
zHRHZFQ&M{1=4kI`T=WY8V9ki(mS()xEazKQbTz1z3|w0-^n6t#Zd~Z9B_sx|EavUo
zh=abk5qJN$8}ZhYT_fJFLr{!Ik2EN`9W@y0zoNmn{8ve^o4(R?ae{6K?^q<qC&#*w
zHs~gJH{(#qI`5b)$J5?XDaWJc(8i7jy?0dJcY8;H9KY}m8L@&Je1hg6<-NP)eWiCS
zlH+3UXp>`_PcSn$$9qqfca0oWcStbSzTEtJ-cqnnv`~|!VB7Ut3YNE?>QfLGR=k#3
zHx+cty-U_DHZU%eIyDb(Z<>6BX!)ke&WVI^`|er1-1@4#boFnzbm*5Ll~`xu;ntl6
zm#Ms!m|DI2BDv4YmLHre_tc#G6uB?Vxkt)<an5~++&{?Ww-;_zVj*oHov?E<Wru>u
z)=dVV#$EV5nebr>KRg@$65-)7I6Zui`}pfJ@n55?@Gbti{O+*uoXxg#8bMUK&SGGn
z03L~j>f{F!>MAyzV5N!ROzdRweX+J6I8*SMeY5=zVPtzMFX1~lN^s6%Pm+i80J%Hf
z%D8*A<9}<8pL`P+lf(5ma`ezE-oKcZ@#Q}g>(ky(5Ju|9d2Q9+=WA;e`A0e`_##$y
z4z5(+j7lh<C<A$Eos%?*=dsIcP{CTmupisP@DF}SeT27~B<r6%-j=+gFvDAL6#0fP
zf@EL+sXl%_o*%@xnTfxh;{Ru^T|XF)drHpzy4>2x;q%*d8~OeE3)-#lUzz%UPLoo(
z4ew_2d7N@x`@2eLDyJlT&d|vEOh!4ZAItWek&f@bue?}7b~PW`AJ-@RllOf1dwdWs
zK5fIq8@!KxU!A($Ou&qm!v21L-E8J)*k7|d*@4%LN{O2Jv2{?}9H%Ar3PevD$ptT(
z2BLM@<T6^&Wrw&<Emo|s$+Cwoe|l0M!dd6q`{lg$J_shTV>@W?3qCZsq?q<b#Q6jm
zBF^N4M(Gf{pkMcm_v=i&pYgFU*o*SReiY`~u@`-xzg}6w2RqV66L7Hqvb)N`o6$8o
zkH(+i;k-nLJ3|*+x8J8Qn(==PQ|;Vx{|4Kq1?Iv${61w`%{Dc6@VlIR4Zq(r)nF_q
zNR!DCs*G34vkJMkG)pNDrxTi`XNF#x=GGYh0VKXQwTCkWNA~_y^?A30w_w-d2%a;t
z>uBYFll(s|!~dvW{ucjr`M)e0vwCLZKQ8}2XZ?da#))sT^sWPP#IMTx&-7Td^Y(Ht
z;xl}BLl*v6dW<cdQdxG3kB@hc;&tT3W5HM@ej0Hs+E*jR!wNCrhx1KLKyQbr{BM1|
z@_%WG+LYawmOnEuUVeXg6KKlPPf9pj7~C<o5B)UZ5B<#I1^uvM6v+R{wN9)99KQg_
zXNm5z?Gs!?`tWqt*Lb;euH1*@+^5LhKj$7P_sco?dJ*;Cnm+etm4)k{c2@ikv-}Wz
zItF*UWP=OumV1(D#<^d@t;O%FKvLKySe^fJ#rs#z{YSa?%;odT{B-{*+2zuu6fc%5
z|1!Dv%es5<=jZwO-Qe(hisif5n>x9e^BITVryPC_f3E)4zZ%#9=*jTO&MI$Ou7016
z#{F&O?dvc1?z!-n<lZOe7XJF?f0YS4M@Je-?74*nzH=A>Wf(F&>O2hZ;nk331`gq`
zZ$4Y{=q!EMFeUk|k$$E1i=D+<IJ{?mzK8W!q)s9Q{qp?9_s#Mg2((%v`ajx0&ig-Y
z7wPhF*?hTIgwOc*srFtTp5fhV{rhF!;bKd)B0Q%Z$1MISryKlxywCYQ1wO8S@A;4m
zJ6stL_;*5iJ&q%MPyZHj%tZK*ok_7gT;t!*`}bY`{R;1J5XYUU$aeoO2A=SbIOsFN
z2VL&5w3fyp6^DfLt|hpWf2!bQ5Bu-E`&9qF*S{aI_ww*r@BU1A7cFp!2YJYc;ST>v
zMZ>ohe1%ncMOY#4&kfQQ;ofr8>fe7@{a1voKI^OT6!;4i_%r?c4gUoDD_|u5v{2-O
zZFJ7vX)&}qHJuexBmQ=6pKGqU6IgSZw^Z6Lxx`R*J7XZ>3XG!$95@tKjdXq{sn(vk
z!ZLF{giUjdxRUIGtB)64?!^CN4Mt36LLqyc3kriNRRq(!($_p1tQc(&n|5}L;#vTM
zU3a`L_fKO%kTt`*YrIatp!48s*(y-60`o9?>oOa<*m|KulFa1f4kz2)P9hsYoM0`5
ziH$JHV{`i_My1g`?!2(wl|^!F$rAM>;ZBM?@&pii1z(<j56QTLLEt95okr+&9&6@4
zg?V|WuX5@VM^yYbDcj1AV#{VC9!nLy{Y|q&PHtD{Fyi<$uN0SC1>YORnF3(@ywaIq
zdvA|zU84)O=ehkhx$|Y)<`o{^`unzd{mNVKh}>JbU3*Y={El-MY29-PbtrgvCjWv*
zDLR&($Jxo1#qy0OyB_*T9eDd&oAH}0zhRrxF~H;+RnDpduaD11zHqYQ%1U}*C8-?B
zcR85oiLWdWf`TRxsRnhca@LD|biPIUJZ*etgCr)L{Zuca3?;{_$uX9m!xB=RIG0<l
ze;!*YZ(XBC$Lgk*=18~Tk5Es>R5?XC%b%Mb*p;*v3@L7z{D#_@71J1@e&<BjtUm!X
zh1gaoM=z7)X6HbLekufBNpSa5q8Ot}$P~qvwL#Y5Mmm|Nv#J#b$BB$ZNp{Ora0t%s
zE{MVDhrwQQFADmLEZ&4y1v6)09015+XuQkB&C_92?)&s_CI52$ao&1%JHOZFE|W)>
z>SUcWOH1;Ih>0Q8SP10DYD};<M9m^xmU9VZEOjotbspT*`BGv>Mm8w7L=oWSwgDIW
zT~v*xG<*;B-;rS*wi0Ax<s>%m{}(h<js3fPwB0MCQYN|-EH}w~#Pq?rX7g0SgplP^
z1-bedDB@LZzvkRoVfB^$DN{P*v-;o~Y1@<iJqBSx`dI3sA=xZk>YKYn=Q$%+dI#q%
zhRpN6#(OXH-bKM9Bh^X|y47Z+FADyE567j=vtz+-A$ztko;3;U_4(%{S9b+P>||_z
zjWY+&A*g*r;kd}X8%|9pj@nXP!TF9YgQ#FMen{02x37G|oW(*VXFBRq%RAlbFVHy8
zqfsbr%llrC_bnjxBg##A-ivbHx952a0s5K6j&GYo@P2A68*g=D2o~H%m(>*;AiA2!
z_<s(6Y4pabN&O-nzfcCK_2tSSeY4wv)XpAPZq0M;%}hzpgz{Lbf2pR#D;19^BUQoC
z4wHcT9=X_-@<lqH5yq3>(yiMvcDjhD*+fcRXDjv;SHML&RuQ-T;}f~ZjB#RmbRo7!
z)sVZQP4njZY`Zgi`*_9QBiF0|)Ocz(+xR(I)UJ{)(#<N@{t;b7;4uZ38n+f|?&u9=
z7P5YlW0)WFArrBk47Wt?tr?Pha&&T4`&-=nw+@r{7l8aSkqzWS`RE0*pw%6exjW#w
zB{#+m@Kz?9ZP|_A$!3a-Afc{8er}Tz%n;{>wQE0<%@NAnE0*?gV4tDENC`9bM$5K0
z60MqaJ4a4l4GM3MI!|p8pI~&LX3`Hziuq5G$Ap~s#60iG{yWlf2JK*k&kn8sPzD@0
zV4Ie&5e=osa_xJtJsitX{%)2zxS?F^wAfH?67BuirWavb4i8rpuFVVHH;&^go<4rJ
z*wRn8Z-4VdfGN&Ekly=M7-a}fWhC!vDz4&1aV6$|oe#g>ulRNgyn}1cgQ{4dWO1&y
z`o+@j0Mh@sSUOYsL4z!~@=D?TOmzacnomAvC`Fj5E_@9*lvns;NX6^NM)~=KwXteQ
zzewjTqPmeq-{oQ{PIkZ%&afTO-qdYUF}xT5jQpoS(YAiE^hxjr)3qvUnZ>EZ^9(M%
zhF+fLz&M@cSRA?LCuEtCOr6tR{;rXkNH$~tdGv!7=jn8bi;>6*i@{g#YYGREJVB+6
zeo)1RBk(i(7%Ngl9zxAL-oe=U0RI6S%ADT9{MRbM=to-PlGyMw>s%L?b`cbO2V{oB
zGH@?_9cp+rxb7Gc!gZeEy?n)VR`GG9Lw6#@(xW%W(r0rII~T!ouX?~e>Ys24`-g(%
zeu~#`-&p7BNXI|q#c*Ax!Y_?I6~>nSqrdJ`9k2(t6AdP48Fwl@rTf<(jkW(%_pg5h
zSd=hek67W`v5H4g{<xbu*)Mp01V9ybOO{FExap!pm|9c`H2VU1a%Hec+UP#Q7A#>U
zR<S&C&B{+`<M!nceK$n!s`)GBh)$`ts|H8P3A)dSHjYghwx+t`*~CHBv|@54Gwzkf
z1=X;^(BLh&MYE40#j<MABlm5=6&ys#L6C#HPs#O<TtXjf|5ssxqqaWbKC{@<9O1FL
z27GK<9pCY(>ixQ6oo5xqBUMXd$sG_#ob%JZ0)2U9F?o@$b(M^FYG@iX#!GjE7gux8
z#qy(711BV_3ttyQs1nfUO}q?|o;Hc3ltPrS=cRLakM=<?{33cj5u}+N_>iN}VH!4P
z=qlJt?&hr9j^o~(tFI<y+PkQMu4<mMIaaZ>^&L|Rjz_@?kK~`DPly7z1TkClZgwpR
z_El3nn5pF>v#nfArT`KY^U~a|5)xhYBG9Tws1gw<1c-(w@Ycap1#%Nj?z}t{n^+Th
z5vW&&z{ulvIg{7B?w8=nxP$cv;|a!;p<y_6kCip@9_1D3_=Yhoa-C?_J-Oht*B><Q
zII9dY3%>mnievj{Xke>$Q(P1HXfu_{#vSBsI?XFb(#YBFV`XsHKE&QyYr4*a2y?_F
zH)OBYURN2+J0ImMm@%9-dyp^exqaov&XNNAW!sagFA@0ggx)$@H77Ri!6(@Bdp$kY
zuZM?{3MGpkEE?%3Q4dB>cAr(=83jSfZU&lHAhLb9J5Akpi-sv(eESt@#-1#=vOaq=
z^VD1Q*_&3!_CsDUizp=c4kJT3^0#hU<PL!PDNJ#LNo)lQuca;-Ob@q_z|dgf;b5Ow
z1%}qHNXMZZBV_9dhHCu_0=qbJ?YXKTO{7RlxFVS3lPy#s(sk!D$QME_pG<xvsZ_qc
z2NtcF8wiz9zu@7$lsEX7;}3FVbha!eX9^N(XL)BZ>A}fjR8t>cpa^}=iZMg#B0jzt
zsYY2ToskCo24|+se0CsA5rZ8BDoZzd_Vg-F7~LdsGR~Yele)s~+y7A*xp!&2;?c-8
zgXn^gjuMS&&fe<WqxImNJc(C45$X7leuYbq6-kN<5hYeTcUzfQr@A|M=sv|7k_<w&
zm^~+2fJ^~IHd*0iYDU0hB@WTV&_pZdm609z=1Ukg)gr~Z-U$tY^CSy_COZhdhe!lY
z<RvgC>rJqGd(9pqni%OgPwV!QV=LYH%YGX}`|_Cp=9q#HUp4T(fQ<CB>Io8(8X~&*
zjtpwKod73tB7-hlLSUfcS6SdiH{sqO_iA&WO9wL+n}8FZ%9T%5KtFj4ZTj&k)aWN~
z6=mOyL8B4h-Dbus;Rz@?8E)c6xk@0!1Q3oTQC1(5O@Q_?wlvN7Vsw#S>^6qzZI>&x
zkJrlW>PlwO=OfhA(3U|Szi0S-kps|BUP(^D#SEauO$rF6$&o4EGSxWMGOj@A3TQ?T
zdAzSVrLEbIby=k9H5g&k$uPVZyS2Yom>Vtqmg0@$uI8gR$8r83qYspW9XH1|Jr&#U
z<Bm0Gl1p{Q4~10gs%WLwn495td^<*~bRAqyLxU6miGE0+!~pfe9B$qDBl_D|`xPY!
zVx5|4X9z-(itFwe|HA%%Hfo&ufBJ*9%2g<e-1}IzHvsYGkI-IirD|-`)1u-uM*1Mq
z`CW3zU^x81EZXqDYd|_7!Jypc>1}ww`VxAghXiqI-ppXvk&4Vs3b8cHs_2K3%Yv&|
zlYj!rdOiN@07Rf_)@ce+GSMNfWy(w<w@M5Jj0)h0FmzWuxF@>oc9j12Y$Sa;t>o+?
zk$e01<0Ms%Hd4}em~5?19XPg#MStyFUhDJ~#g#oKZz;s?61`VHA`1@3S>+v!qv78*
zg{pqqcRR_I!3TrE`A*DlI7MFeKBx01&bRL@UtBgJ&+zf4;hyVFawd{x&MPXfqTs=U
z#RV*0mElE$t>CxvL3YGO!kMjiyTJt8?vdWHAWfht9(K&0^=0KHLKS8sGYNI<YR%>_
zmqFP7Xvm%Fi?BkCVs!(baATOKh#|u__Dm=X|Ax28`z$1pPS%h0gc-UDo*s%$ax`8J
zzrk|32U+33f@yQo?HmgI9ZJ3(3*(4Ujew9Y8lzWa+y)&xpd~R{@A}P$g@W@ii-GRR
zc=|q-)rS~gmj@p|L^$y)6_g%atSpkRsDEneq^a2}Twpo5<Fwxj8m^EptF=Ts>A~Nh
zr(*u8g-Rz9UnH&gDy&3rJLqMEWEUZ>3_1jbK-EKB@a{f%vI<Hswl(_h(6rB}wh~5t
zmSsL+)FphGU@i47=bm6TITtLH@@s|oYY?m;yR*t|z(Oas9N0lSxMCJStaKJ&yZPX%
z4#9tY=}<*MM5$2K>%P)FAUFyt3Smw4fLUSwc&O97-(;oZ0+6C$l=;wLaafgA-jfOw
zjhc>CjLfm;SP^#j*P;v!1{|oO60#3-j{*c!9Q^n}dGR%Tjot1REa-);${nglc9hN}
z!^r$svIReK5QMBU1^+>Zkprh_T;!@V1gGZBF$HpJ*FPa42~d?_N9xJgKBA+ruwXQD
zG(GU?(_xxliAEH|?UL~KQ>-V$;2h&H=0e;RUK#Y;HDaB!p>t%BJ5pV35jNoyY^0Xq
zg-r5E-FA|0i8|6?)cpi>GcA`B4HBG>QX6%Bi^SU!LUS$=JpV@LcD)2%+IMc(;s~#y
z_^trKRv4av{?rw)WwJ2blb#vrHjwI@bPErVhe#6ex<@UHt=ww(l9FKnrq;k^_9K~r
zOG_~YO3awuqT^7U!IK)E&=)B${bIewN3Fk%r40+*c@Z4_C(P)#X0ZU|t|P$ACWN$J
zjI4McJc;<3u<{*oaz%XD-!)J5(f$r$H>ngMZ2P$mVTNqq#VJ`OplnOWRzm%Pb0z*L
zULL`zCJXzQ#?psE8cua%nLZ$u=>`ewzjVbc^c3t*Tv;?bW~iMd6;xE}%$KoUI!lyL
zA>~g$4dY{q!1$fhjQY``zY?4l)eJ`Bj&RAv%n@YshY|h+DFN1qISnFdiVr?8PJ=@K
zMDLa5t@Ma9h~aRy^xKjZ)fmT8B&e>q&X`7Fm62<1rdi|Z(fur{pcRMKR4k2LbElMR
z#=+vSSOv)=?LWq=I*DfZ7?-c>j`fPw+$z30&K2y}9>{p-<n+<p%-$1R1^mXca?CkE
zE#UKkm6(#FWQiFQ2Fb_FWb}#8D^~Gj<l6USBHa#Qp!7$QSq3nK3kNF#MeuiW4WoSd
z{t=XBwbOk2+eTK5fUlEhIuS6~L<kL;I=+<SHzoe9c{E)Gbu1JL0grxW;-vQ13qv->
zxch*0fmwu%KAzz+`l}atmO{P8&CWCi91HTAR>T`DR9q3`_jT}}ih_d`i@rvsx=$|<
z$UwBIU+_Ew+P=gZER!b<<x)A@fckv9F(@egmM`lA9We&FF}JYi%kfEYo2@Lr-nFT3
z0pa)wrSgsM1o-8~Nb5z>?%ufIWGk2U3n~pP2SIR@d3)3)!7MtB=vOAT`Hz|wkeL{?
zIW5C9relT;s^U0^({M8bG6Ttx&NHQjrAOQ`-649aL|{5IT5|lTUOp!Lfh@iC(}tJ{
zd~;Wf42OisWg&i4*PHDI0IB$=eP5d`>{wyCj4Q_-5!${P)oC@Em|Yd4pcR>NJlwIS
zRpjt?y@T@4sz!QL56<AfReS2Uh{COEvt~IDlVlteP9%l5k+on_L+WQ!W8>gQyF)}<
ze~dwx<LMY{zS|W(Z0rxMi7A6(wVH2QD`-1}En_@}lHyr}mjrHP(1anu`6)5;VlRuz
zgTtt`C3(=pcDn!o&BhI~Jz%ep1p}h6AgPfvi{!zTRQWe7YED75P%Ql<&@2;*mtU}p
zvcaKh21S;qqsm~2k<QlCSh+XA^`gdq30xGjM<p1@YmqYklN>49k?x)y8*eL#SSPq=
zAJ?R7O`rGDdJV_pvMTpzQ6xDS@m)d=UVb22sR)^mIC+|D(w|6fk;d45aFg?V)-<A`
zjUTIMwr^0Jt};1XO-`<o2El#?S4L0dLPJI3+U1Vb^jpCJR3&^=J$-6#NYM90U|yhS
zd!+X5kViK=M1ow^SHEC|mRV;Iumne_HK0O2srBnM`EV*>=!Ki*kI2zmhC4s_5WH4q
z=72|auxC!EgZ&%Jq(~R|bb9wT_^rby7^bM3SZb7|8*<F{)+>U)G!Xt%3-=B4{4|Gr
zql-_9Rp0eNzj}2loLwIlfE70ia_-L<9L7=*3ku*cN^~9Gd=O|onRQw5<kGMTi!~};
z>tCu<hjc%ZVRMEIOpkNM6i^(ZzAQcB%qgxFBkDYEk}ZPyuR~@r;Cf)isqZ|ZzgUv_
zh>y36Mecq)_Q1&B@2bDTSj7uiEJaP7e~EP5DM^vuZO2%}W0CoPk%NI`=X3hV%#+_g
z6L7TzukcM9#F^ox4P?uZgJZGBd{w2!NJ|Ka44TbJSr~H`Su8Bwj(1z5Y(tDGR+ri;
zUtA=sCdhx4_g6ywh(A&Ot8wQOhVF$-F@3K*)b9H6c~d4C-zq}C$e?;2H&qfDbVXUl
zej}OQ@j9}lI!V2@qcUKXaVaM>*@7FLZNd%0xJ!7W?^F#z3BD+bxrysT#tw0L&yM2R
zQWhE1ilJw0C9x_AEK}ghvE_Q<jOx8|>`=XMR=Rgp%-*T7F;a2T<5=fjSvA4?3l^}#
zX3&*mou6T2>}32W2iHoBrn!voN`0g*i@LG$!o4JK{8)Ksa1dN6A1SfzE8KWF(m6on
zbiXGPrq6}R_F!i0ka3WYrn@3{FN?8-$bS3A_FK(#M?c7<GM4VYFrM!Jh{!dnbPU?N
zbky$3U=NDX9Y(aT<B)Kl-1^Bq03lDfcizFwOL%L&j#nM0YB(8|Pwm045n<tx&^7ja
znp3@i;YG^?{!G2(sh&f>hfDYuys1*sBYrlCKqvK=OFlJIjMqDRV_|#5XZVrz>P7E;
zC@@BxjH0Ql7!ZR8QJ?T_ElOvtf$M`tJbj_Eel<whDS6|xIrUX8iYy7fPeD1U`^*I{
zn&~eYscZL`khYenu~bo;3e4z@6t`qgc{`O=GN_rVnV_8k2*Lf|1eo*rdO*x55LV%%
zNo<(o9<age7`HL$B0OxZ;ddk=9>ChK-&NgDYFaNER;#K@a&ll<EHZvIEqZz^z4v@g
z8g}1Cw_i(x1dr`5X!_F~<u6mv;`QJB1EihuDlq*M2&$9Iz}l<l0#kZaC$O=U=U<|?
z<R|#A#Gip^delXP1kaiOitxE9)TL;uBCQBdvG?+DihmFC?|<+P_nXGQU1+}WZ*uO&
zm(tY8=LT~u4@W9w*mV9K%0C6Wte1!1HTUxHc;~MLOB*bAHg-K7&dvG0k@MYarsbgs
zgWYFX0k~uvPd*bK;JuFW?~x6z#2)WHg16d))TJKQ$9&L6|Bkx1a$7wkOP8sW{9V3n
zG3-82$0zR<6!a__Lc=<JttiBUd#q!rwh}yh*5$8&To`MA2U)d4k8S|xCc~lu?-Myy
z&eFQ#aPkmf>=WKUFT8Ra;m>TyrH_6^cmd&~&*Y}|_IJvrK{B?q&w4YNAkeSU=arUV
zY1ZxH=m>Nw#o|~lbmfZFw}OA{DikiuySJiZ*(Gyh$v52^#-LE)ON@@WWIzInY1hp|
z=1#kx<FdrDl@|#y>w~qs5HVFWOn6Ei4dIpt^^ymSjobpeON^vZ3$oVD);+;cnPo1+
z=5h#iFtQ`~8)XK?CQL^4m&bz!<ce@1EvEL+efA%o6-$0D#0H0pbCH4rW2wRawVvWD
zCKR*gFIDsr4p$ADZK1%WK`5waUB(Wo@q_bQp1<C5<M^_EiJfxmA!DhlO2Y9}(5LhG
z&R<9eUcfhZFt&bEV!1e1$$crI#OfDMz7f+^;co@qOh@Uxd@wcrmJq}28C1IhreHm-
zs-^}l4#rs6dM(^r9(*JR;F@q<d+zz7LMOkIn`5aH)&IDai8}~%$@TVk=r@5TcuW`+
zT%;ee9BN5^s{CWACYD*go8USPi_Z{}yFi1#?k0@B+lq@VGpUgj-@d$z{%3_qCph1l
z`m)t@i-A0Nud_D`DR&cq=bj%X$%0Hf<ZpOC_xv0_N1r9zmtoQ1pvyY37wxiSHI}X}
z9RRg5+f9+bbre7i25^}4-Xgezz+o(P2G|IPZ)EMMgz~ONG=two-02>jXe`al1*=23
zvxXz-gX?cs60B@=F^;dzw#RCTSA)$YmF!S=akk~Fh!_$g*IsT___!x=5Gq>&69e`m
zI~AbfF(mj?!S94F#qPc<gGZrlyD^XUkHQQJxWVBU{geIu>#=Dzs6t>K@Ye^ITLxGP
za#Zte@EG&!a%0J-V6<;iDLB>S`A?^SlkFh~<6poI?}2jkzR$lG^In+2zxd@d+B?eS
zQ@!xag6vpQD9Q}^t5e&@xlh(zY+jNW##-Ir1SE`fWP}?-Io>re+xGGHp@oULB#d-?
zL|L&U6RWIo49bWtoBcBaB&}48sKCZ<r4W2PNtagmez5beg)v{SquISgo>~gt-y~S;
zVIUyNlm~KQVX!l8-Tg|Io&?qA5}!pl59t)V08NJTDAVM_+1bmtu6`$wu0kdArK3B4
zjlOaU3}{2w{g8?=NM?fQW^#3U8V3#}8T@na)jxyl6f5lq;Zk!&ll+8@a_LnjT!4Q<
z_TDI2Xm0dT=7|iOnOL~#Or_~4ZBqdGEa0sl_obm3KvU>pQYL~2nx*z+@@18T>VUGM
zK;H^OgXsf>0hdCNO{cesf&pR;@>2f6s~VbsYmDI|-mAys0*MhkCaTph4Au{zd1*QT
z^m$RMW=^&bRxoF-p<b`jiKN;F0m-&q`VV}|G%J69woX45Zh%kUsqAfO&jiol3^15F
zixjD5&#7e}vU(9}0XC1u4fCnfq0%+2AI4G>F_L@Kq(|&Qjj|Z&pq=6mWjiYwJAT*S
z<}+RmZi;-~qa_MsqcZr=!P4CH5;{;WRoSeTj0NMGWTw8=j6Im|SA;AjNCx7#fx2kO
z-<9)L@b}wP_pykVJ6)3)`Yb0DK(H5l(#Ys@iL_(0@)MLESWN2&7el9-_t5~$-JatI
z&i?kC7l1dj_J|vE;JNEuT&7>_svO)JW$D_4m2TFhx`Lf*c=_9q)j+s1H`9#O%)`i?
zMG$v7D-n10$R5<JTzsjQ`BI&qE49tSbEVFcJIPJ(*SVy=^d(pU(I)&-IH+YJ@!}Ps
z8YNQopkL#+*l-$84`4Ok$B}E6+o%_1TX|M&aWW`U<(DtWU|c7NsEQy8F5gMuyM?1}
zg2d0l0zNxYk<w2^I-XRXV5dxZddyY2?=0rZ<@SK9F3AnL@5p@HH}{KNbA>NedE8Ha
zfH2}g$=XkLRI}acrh4ttqg(xIQ=6jcxX>3~l2>@NPvJx4b_ld+eGzEkAW)W-nu>p9
z5a_aTW|b@gf1=R|=qXU14uQp>+nd~kKpk1H7%D0lY2e>ky3VSkJDdE)7{2|ND?4zv
zTHzjd7B`RT)+($w)yXT;p@ZsGk`iaAZodhXx}w-MTbEKA)gi(3?V2rW&1NGzigp2x
z^elnq8&im_4An1DO3IfQ)Mus{C7^HzXR9=cLk0Tz#qGS1T8*FUci$5y5KCyOu6T={
z_*L&yCRF-4$j7~3v!Pf0^`E@YLQAJf@n3tNdlaXa_)Yte2|mXXVqfb0HhAcYBOSL1
z>N@j3mu)2stIsr1ot2ABH=}gP1j2#4UgB}#QhB1*`z%ss>?~5~P5K636RM?~j4ckH
z-$6BXJzch2jdb27pb)!dtSV5~n75=L+rOGoNtv_Gr=<J87qSn;0r*Fm4bDNpdOe3~
zPgZ`&ypphnL2u6AC=>tUa4y}5^T$+E$;A|Oq$CQ5$+lp65&rIe`8N4qo9{n?_-@f!
zcvLoj;=B8RqKdDZ>a+Q{TSC_Xdw61gx$Z)YF8Ti=>tCJZ;-KLuhi?ThKq+R$lm3wP
zUmq-$|58eD`eM=WH>hrU#Ijmpu{@YB$>iE;@ZaQ@p7RgaWUtaj!2v%b^(74Z9elx9
zXf*r~y8uI-gR5!&*S05pdepb{{ha&WMc<F{9TX{Z_Tb%nzTTW&lZS0Nawy*6f^3YO
zXViIyb8~@{GmX_d`BxXv<v<A6`S&S4?_u_4<dzT32^ML2SnA(9`9x1Uckjpt;+eN!
z>FRfGr;YNIR7ctL!KtD@!#o=3m2))}CfY<<hVJvodkto6C|jBIUN58e3wA}dfF=h7
z_Zw<WdjqddJA0lD0$R{u#v{!tQmHobp-rDq4>d%C=NKN)J8G=;^J8uX@hG_S#Cpx_
zF#C=g(I0j6`D6tu^O47wA_H3CNVf$FBT;kkqyCD@fY=n!?+b8Nc{fWJE7NseNv2xf
zXNp?+4;8VkC?bIr%U$bS#zU3d?2cZ|S}rw910N}{On9<f<E`KV8Oi}88oBp86_!=X
zI*F|SY=~LEI{b7ZlqN7Z<@;ofr=>?dh5y5AA)nw$tKqUgp%BRe{TB@(p8p_HQnWpr
z`E8fqn6lW)F~!6MQCKa<pc9QLkEQ1?GM_Ohn)B6j#F9Gs9`w#HF|wS$&beaFW!+(V
z{sOsHj;XZlR*sqH-t#5p{b!K-jN)a!$@vp`$5zgt?0r6n3>t%}c+i-M{F}d!Bzmv%
zZzYnuoOfi<_XUBRDh#JU;B}LGt>P6+?i$=E7G1-?IGT=@FCYVhIVN<u5Hps%+9DE=
zT4G-sDZK-+2R}myXoU2t*g-cpZ}Cxr1gW{p4|%>FL+;e5zrL%Y7Otj5Nb4Fyyfrv9
z@H?eWkD7#uFStBQNyvT?$YKI*1B3pp7Fk6Z%4F%6Z4ApIgP{IkfASP8s|*%T3Yo*Q
zZ`jU}S*7SB<JsmtjqEa>7vX6(;8^OA;4VSKeF<i|9rXjV2CFZ>LH%KMYNR^xWTza#
za?)|KK=muCC!8Qz%=+~k$_&TufX4F;v<#aJlCqJq4D{8$jKv0WO*SQ@D5}!Z15aVj
zNfl<!Kp0qx@EEExR(6Ww3byZ0N=?#ts^J-!ecFwPCgNH!!~G(iB?9i-4mS(Fd7feV
zm5KQ6qS^y#nQUgl^oDa4IO2~dkq;yJ{b5nzGbwLat1OSTwl|j2KrF{@Yfw1j$-D0{
zFh->*0t5wj_H(6d6Ce9q)){<UERA(5e541y00!diRjMRtF!VS~q>B!s6k&#X|B<N+
zd9SNZ{?1U5LlBsF1Wbrig1ud>7MyU7Dm&_#v+*nTFlI3^*aAoVrpjSr2vi_UJTYl&
zOuS=_*c%hN#1Tv^5hhYxu{`PrloCtbB9Gvwg;|7PtLgcnqYrnW+-X)o1|M3>XZUEJ
zpsx&lv>ScsAjhI(lrI++LKBI<^U3s3IhAw-0afssF0%Cr$@X&Rx|x$JVo3}h7Ix}x
zO4XjFq~uuSUHfYC7%F6~heW9Og7K!JkNWj@@q4Mj!JkFe4<-teBQ76DRv4eUL8g#(
zFy6Yn@eo>1qWb`&<6F8^F#R9nQD|xa-CytmDZ<atBup<^*{Ry<7j8gT0ehp>M$>$;
z^b<}lbe^3j7lJ+_VTBV3J!)8h=`a`(9X3XW=It^xRS}R8D8V%_jexw8cPyoFv9KjQ
zM0FR3am_DLs_9{4GDKG@Wl2zNDSLu(N=fyPw;TxJ$jg!!5w@LIGYd;CE)(*8*7KS1
zT(%agX>n2Q3jN#Arxu*)C&5;csm0GkmS0kfF4|VLSfVzz&XBI&Sk%_QsN;`Ha9YKK
ze(HjW6$PU~y{J-{YNZSr5|TxG1^_(UXIXFWp5T0CO*PNr9cs-$FmlUh%%ISEUN1aE
z?u&Eoz2rVB>o&ub#LEFpfRA2s1Wk}LE4(Tk?WyW&`GO6zs!=)o$ZnKKhn;13_+h<>
zWHfY!o%!Kn9KjX}i>>5KF_%+`v)&>~#AvI-d9O5X(sy`|=qr!j7NV^O7kv)ACuH^T
z;9R*&vwD1RirhQp!bi%zfx(2UzwlqqaVOHmV!`45t1>9%E1b)&j^Gm^<mof1Boj;@
z@D2|?i+{89??(Mgf0uvD^i{!^V!b4vy&!lwN_mIJc*nl}od65r`wHnNb|l)N^0`7j
zC+h1gvS6&?7GAcg_QixvUx?+}EcD3_g3&t2Wlc4=9Lji{3~Cq*G{-k>h^P8LZM3nO
zWGHX(Bzw_LEABqfjU!H^58%E~3p<S^32Z!3q6+5z)e^CazqP&?OGRSIConm;M!Jvm
z_Tyu;UG~80)TyLl@f>NYNppQyb;aKz*Ds5%ZvA^qtJ*p(<1>o8OI*5&_Yy6!<dd-!
zoA}4WWfO{9+2}Z)Ovs@oy&L;TpNgmGN|(9#n&{dkR`E&eN3n_x3HtxPBnHP)qh0)X
z#Z!qL;>n|*HUPg7{Oq&OdL*S;>*<b-F0|PW=xcbFeJxb_!+WJ)sq~Z>PhVf!CSWU8
zCkDk=A~uArNcXQ}$qn7F#jy*t;nV$Q-s}wdYP`VCR~<XzCxU`uh`KoIjDF9u4>so~
zcCSt?QLhSHqF@E*eEb;#w)NXc(N~|9@B7Xa$;8l26u_j==<`QkFuGP#LzM(GOS36B
z&?S1DUF1ly_gVX9*21<S<lFt%Jdj48t)&?8<fg3Ix&57)vDCv8h?qB&!PYsvD>6(&
z3k1pp%7x+l5fV<=*nC~>5NCex$11#3E&UWNmOgZOtm5UwIW}BHw=e77A3V6-;>_th
zS}Z#lOZ{I?9H!wyOcHN`*GkJ`70<OkBi^dySc_o&L>R4oId-d;TWLaHz8^po(2WGM
zSt_G7p0R3(xl&TSxF-2n&9E2aOF!9;wa$V&jSi$Wj|7%1JT29~J2!36#;O)Y0S?gC
zrA?SuR>n4Milt5}kEQyrW}?eDV~a&XF}%3A``ezrcZ5_T9dB63#l{yKl(ORKNavGy
z#w#|6FB-5yUOc3_;-kb#ahR$mb&!)IvDEn(b^ejKilJZkuDShPwpp}dX<|lf<dD|)
zwfQw(@vqjWta?__IG3d7s#wEm=GP9z%2C6y7gXWZ-~lK>UEIXHk!FMSagWT*GoWPV
zTjCX`aRvl4p|sF9-Co<JoNIiVigkNdy4yu(@zfHLNIX4TH|Vqy<=wEAa^n?mw+@K6
zhm`$pHNu<b+`&;w8hS`iK&jg!mO8t5<NP})BTFY|msF=qpJusmYqWck<)37Fb9r&R
zeJMGS4MB+`til=6sAethgx2RpE)bbf$P>Ze*i~cc$myvph3qOI+5^ho!J6+Oiq69z
zpx>|c4G#mqev#^7|3Ip#?}>8U#dfiZ&5;hyoM$*mkIAsIAoeg_jDA-!vuK>4>9)BO
zRpO9f=H}0g2!}AW7cWGEN9Bko_b!R2t4oTR3Ak#CR%u<O+ugc^;+o`XB{j)Mq!RoE
z-F4~c$e<kz-EU#;2?q%@t*laqRyF)DRl~cw?+g}i{0yP-Zmt&LCL#y7;2rYNr>`_I
zK^26*A;B4+dZ09`2RL2yT&m$v1rvuEtl&R3iB@cdwEUo&A)#$kg6D^*!wvVM&e=Kj
z2v^hlbsz{PQH&C77QE?EXY3C<KE%$%;A7=V4^?)$>#0uk@7;MX^ye?xoG}ZtXE6Jm
zw-A6yzThVe#>9xtl?X|=BerQHQq8fW+T#<IoMN&VQaGi!JIhad+2G&xQ>Pd|t|Doy
z;(6Ck#Vh_Qemtdw*^nWzVXLg6=|nn~d<QVwHy0)@Z>ul+oKRx43}KZ!-O26?rJS_0
ze>)YAq80AUlDJ3dkJ4j$9uj_R0aW_(?Fxg%R_Q7xegN?Y$}-)5t%fdbHD&0QAS#a^
zuNG~!=N%nYNsXZYdC`86Yv+P;HW8z!SCt6M?d#stwH#Gt-HW9M4aF<i_z~2Qx}p+1
zIc+GOTvnZ&%wn@jOT&AJ((;b#ZD`yiG*%<k=s}qmjdZLdB%Y$^SaCN8<h9|%!8nl1
zCmylyQ{i(-MVMpLCOXqdr-{oX-Tz-(pNZ27GPtN)(iZ$mpi*}s%$RMbIM|1k&;Z8F
zBQu6YO~*l~*nH>$PAYSUC##!E4}9)XN=^^H@mT71A=}=(Kz=JYUs+0U8(s@1fLB-!
zrpl}z*dvy1VUB?D2Woh@H?-*FYtYWw58bb^0__Tp8hFYMNqQo<D=m^_y$?7JzGHc>
z2v?sb&lTbJ<c_|?hOHYlXfq{gCHkP4Yu)HJjz=%l3~yd%>ic)sxqpVD^(?CuK4A8m
z+3`H89*W&b6Nejwmekzh>XApXoDj$8<deZ23@9?>4v*4@K<<^k_j%r`eG|}Br-sH;
zHO1Y-d^>S|24^2|%*$m0l@Q-bj^L-uv*L-?7YN~Gnbs0QQLHfV?7neq8C(8VP<m|G
zd#wKBq@s`MDf^RRco*yEbjSl!;EzJ}(Cz6^{pHWo0k4Y8e~L7bj+gka+@5WHK?2OK
zk$VzpS1L&sr>Tk&XEd1aClwOU(1gy*FA)H()bHGqIJU(h;*H!on@DG|>#JzA{4Inu
zs@Lz^mzQ)un%7?rdry;|t{REaz!mAhhzLgme#NSm-K{S2JvHY$=k3HE!`F1LkzPVo
z!yUwOj{d7USS+0c8Kx$!>|aWC3$hh(RSRRe_{NWtro}<s`;xePfu775Wo1n&R#~0o
z2(~Ze%nk8P@2SPBQ+vaiYv{<G-V&ER4$eH(>l=<Q{|Y!Ubn19=xwW_wOBG)%fAQrL
zt<Th?4l&YLgkNySdyXlcJU|yhathk^W#Y_c&za92qtP1GCX<tx$x*cQz!R6_P7f|P
zTHdyxqBwZG#jz(#vNi<|DRZ*J!iGF~uG+CDQX#{hL*nUH*mG0R!Qdn0TK5c|gV)!?
zpZ{1GZ|?$xk4?+9DfOMdZ`!fpIJk@a!`~`f_;aCu-^M#j54K*!mXt+%@tk^+2`nlF
zNwfgTO$0*l*`6eEd8QX>Dem4cOJ6DVBZ<lM0U4d{J^GN=)8Z8$w!TLH0l{jT%a+!l
zV~R66&IWND`%)OWw#raI3qjck{Jm{~NTjpHB0LiHqm6MGs7;O^jtQhXRh5(Dp!qB0
zIHMp{qB=FeQ42cgW|}Qd|FJDO?)pQ~%TiA-Zs=z6JuAn*X>$A?(aUADOIC<$G+!J{
z?8+D7zh#rE`R9bV>>BBTgO(b#tQk%&zw(m-D06QGHz`Y~#0l|_Pj*z2C&UlV2=NOT
z5`{N9A@2BncvpCLzB{<%UFhb?Z2O~6Ir@3cPNrEOJbtaHWqDW*j|PpDtffXjqfEX3
zz`L*fjwhdYV<C;tw3H3w&GF2cRBL5io)p&tq!e2;O%IleOLhG2BaKgE=(}4DhN>A1
z#Tn@wz{<1$r9gBHtF(@GI_t}=Z>c-8jQprZweGDhv|gE06*TVSq)F(9l^_$j*=RB<
zS>g|IbhzT~fi_-m?_%A;vc%6~6~&AnQpcC}OrY@}jaBq7W!a&~3mZNHpl7u-KicOL
z8!T=L-UrR0M5pB+jC}{zn<FF+`<I$;Mc5fv|Cm{?WLAZ%-x2Lqr!L7y6<6lq3IDBr
zBgcQst!sn-#v=L|SV>+~av=@|LNqz;T(yx^K~1W()V8S}K%jYxZ0Qxng^|vI@~zm|
zy0!+&v@11MNUi?c@R!v6M3}D?5!<CO@d|{Py1XH#O|guii=Y_tNb8wa@vYzLK>JNr
z^VPnN^VFY};hX)sYw-|POLXTA>f&QD@w#k@k&gX{L+?@Q+hOmgGCAmYE5Zwv2UGvb
zqdIj$4ODWaHUf6xj@&z1Tkbnn^e-rIJ5WJH=ktVYtST#P{g&1+xp=lUzvEYgblIj=
zCKDOfu)P7FSlZnkWGC3UDp#lO%pO#uy0KxrjLx6>QLhfILre`|fFvz;z~73MN1;2(
zK#|Z8&~leCUb^0$k~Qp!*wQV?w)Z3RZ3F<qRIYx$l6zAD_F(Upp_j~dcvrU04=4=d
zqMpaOI>3amtWMR*&1Q9?Ic0T15j8@%QR0zB$k0(vpLcer%Pr`VtSmMqRA)EDD>g}=
zKQ<0=aLCkdzMrf?R)4c5g>KZ9*s}(ku8dEsDX+TXvBYcD+Kyx+JM1LgyU_nLOy@pb
z6~Z)T>KKNq*qp``i!o($B4O6%v`Z|xdLjC743)WJbL&Ud6^tGhYts{kE^JOGx%g&t
zs!3u~6L4k0!EYmjGUld@?F+#n3fMrnjit`VBDEn=FH_ulwLGzMHezM`5I=T~bdJa5
zVGyPVV47e!Oz)GZkZ5IqV*kp6Zbqu&ccjeJSUa9R2yU3r`a&#~E5l2ilc@oxiX4k6
zdma)hyr&8onLRH%a<4&bWV8TyITeoZ@T6S3S8^B9cacM@6AYFZkbzanCntxv(}I|i
zMHr-d5Jdtu#=tJFmf)0b*2~(Bs4<a;+RB+FwFowrrIIy9B^yM2sq&g+V1)8*&wq|i
zp0>bzIzcJYxZmtBoHV9mJ!335fiPP4=sqOV-`8NiWEr#>D>1}*W2Mo{n#5~ZD5WNx
zWwmM}H*7YKCN5;K4T+hxE6+aJmsT8nG=--Zu~SEX=FUZ%gJpy=`pViU1!Qvj;FGuV
z=p~-l<M@p)xlX4Sb;trY9_0l3_0%y@)Nzs!ULxw?UwQDijp~DJF@a69bV~0RnP8}}
zIFQN2R=S34VUdn|)o<D1S$Fak9Q;o@hF|dI@jn{*+P}n|7ZM(hA>G$|eK7ecCA?y2
zfm=GfG*mybK4>5V8Z-gg%SG#hGTO4;Xz}z8CJQ+^>zmB@Rj2A98Rl8t!kT#dp`}Ra
zBZwne7|<Yj!|DOrWO?-?>XPy-U8oAyU$&Nn`(wt>j&sKku?d2#Tm7lgaipUg=8QuN
z-QQrpg!QM~nSr09V@F8qA!b{4JFavl^h}@Y>G{Q%iJ003J<t4Kr{|gf|I_pF^d(<T
z&j-JmN6#WM<UFmH6?uzjt}haKTN5>cW>sR8NElkTf91huv__<dL|&z6d5F<67P@hz
zlby)(WkfnyZR}~8^$R`01+PQPOz`B!6Vj{H=bJ$LgX|E13nef+(FULyxt6%m^eYJ!
z8bP!mkcQeh+!0B&XI>H&G$Ykm$V<rZH8rX8n{9Bfe$Pp?H<e)uU7iRw<+48_)XB5Q
zEXdEdD47O%|AQxo4z#{#qGG8;+3wv38-2?<I#iNOW@$|+#E~vKvtZLkrd>D}tm4VU
zr6$STJWDk;=7uklV;g(*d7ht_=H%F8k&Xvp&R*>fgf`bQ;AsP{FgOz2#@m0l0GJEu
z>`U{S{B~6?C&$JYSErjY$}`)>td|>)`E=Y0x@FcVgVw|m*t-gXf!Z32SEU;JC~V<e
z3plH^StGN&4cjt}I*IkJT6x|-Xyw=W(s-Z65T-hxZY}(0r#kPFH=c0%^Q~TgW`fl>
z?mW@c&`8H*HSb3+WSV!mns=TgIXgSn#8YQ9pPcHC%IYVJq~{(k8S9#Po;C9!x&AfN
z-aA>GKJER{R_&b_qkZPWsRj=7x(8KPJlVRBYjy4&Mf2?2@~;RpmVgr`I(}&>>Cble
z^b8$vYa_mWXd$cru(+qAv`rDxyD{Qq?oE174qu$kmF?f4i+9iqMHl;I`ZuGCNG6k5
za=>awAJsZJf^37GXr1bmbHv;4FnST+Ray-hS5~~PHh(+#4s9Rqh#1y5CumtKy|Oyh
z78T|+85~rnQkw75>}0AxTDh~HO&g{0CL)2k8}XN$w>i~({k)CF)EZqBfWKJ9N9dI-
zrC%cpP&E@c3SBum3alWvZb)R%=#rZB-cMO;GbUK+`GaBAiL4lB9+JsWX_Y^gC9BVL
z<QkifL=k7c^cz8B9X(<D9kMoZiAy*3=k+xeZ=%bN$l+I$BFu$o1SytbWfbf|#&njg
zuLZZfq8uzr>&s^Jc?|szi4^?tRfzu2I9&gyad<P4!$<HEAIQjiq9DxETO%E(V5X7o
z+Izk;((z|vX6HPQ4NHmU^G!7k2~S0WdU^_WrVy`A4%2A<PNGs?@WIOzen1u;XvCGD
zp%ctltc?E@{bcL;)<}mAx%TBlKH)P&bLBfb%0DTznmyI9Vb=2Yl~%V68jR-KQEY<i
z3+yOI8-H$XN7>t`FJpJx&xWqW_ytF)Wf(U}*6F9M9QqD+!k&>cyq$M|OyVvmXHaog
z@vggRp7h|Wqog`>vINdz%R=_Famt?kIrosIX~%<)6Pag)px<8CY~y4Su)s1XU?>)@
zvI|c{n30Zaty0;!a!l0Ik&@saF5fPe{-LcRVp~~<*^@otr6OUa$<j88Mr?G2Ys}dp
zC;Nl`j(sMXrQhl_1O9yb-XU|HDQ2B9vdM~5degv4R#9w=2DC#xj|LVI4SRKRL$C5R
z8UGj2x0ib1H%ueNn!mWT4fw)iTt8s+_j5clWlK(R;0Ut_@#FwU|2HUsw$*jqqKIzF
zU*xwBu{^y?)=ll5$G()9FYk<(e(3W`)aB*#QJy|ZJ-#m$Gno?B!ykA#$JC2iVR(1{
zsm5=}3NeeqrcN%00a0s`ohl$ao6%NHvR&WZKMI;?3t4W$V`URt5e_VO@8kV@Pya6R
z@3FkYqrGD%-nM?EI=O;rjmNdMFNtJ)+;-<-3Mn3EXHl6Y%(k{92e5zk<HRh^z%5`%
zT$+5(A9+@t#y-X=rKv~<T%QEE*p83Il6%nSkR=xn#D;yc>6PG~wV(A=u~>S)KUFG<
zJHsND+I1Y$vrh+YR}>T^M#gqz<jWb`-j=#>T*W^VnPM!NA~WEBI-qol+;8>hwsNRp
z*VYww=zg!%qLWQ)V*7bmLiSYkQ1S<nZ+$`~wE?wwIqv`a{T~MY4+H;)f&at6|9cF~
zt)H4`nseN7wKcVK>g#6BYMNTx(AZKxCsA-#WBt5lLhGkR8yct8&nw7_I<0<sUF)nw
zZC!J7edDx(1821s95}6@rGD1*g4V?J!^#VqS`*E!iQ1`6t&NF-hQ|EwxplJ|rbQE%
zHrGd6$iHEFL;akB<~e+|G&D6v8(N}`O$mxj)XyNGv3^EfqG4`*G#jJfl7?xCnO_*s
zLJP`<A9>W#BaS(?ykhj2vE!;vDrjt--F)fcQ=8`0A3ht%8|voFsk^kGcJ%3|kDgRJ
zdP1D)wzM`kH_cIfr?gI=UOy)~y=l(uy2O43i8-x}Q|l7-YMrwh>!!@Ak0zR;Q=1y+
zf~V+IuokVGGoy8OePcoa6E026q#{jIE(Ckgp;Mb?H#d-^p)oqGeoE_%=<KFx^~xJ(
zqOM_9%P{4ehuk@JjWg<Nr_QXOdeL#w+S<nG&`V}EOtl&x_`TL)(Gx~R6EhoH4m+Wx
z;d}K%hxG|oX8hv9xofy6jS+2{9<_X<L$j?~cGzWC92%VgvM;;BU~uWES4%@nLY1+G
zi_WTVoB_fGaZ3ZpqdlnJ&`auCNZ2=nv*$E5&WM8TDIkzSEsK_@a6793)PkS<OtQfA
z&1p(qOT*OKmc*Qf#u-MP0*i(Kqm8W~Tr^^oWVJ0QnAKD_t$t4JtcL0JwZ0*bqwqxi
zoW{CY(fT=an&w!{sdbG?Iu&A1K!Ay9#~tTTADu-T0&`+!U1M~1-Mm_dU7vk^yVtcO
zGHnd2B<dQc8a<3X<Pb;IU#rE()h9B%MME9o_ywARU!t=cTA(|%cw;`Y&Nyj&LBZIj
z)>+f6_QtHLM547B@^a+1Uk2W7#GBRt@-oqyFP#Ec4<D|kYQEIk2ilL$slT|jVNN|f
zXx@<8@WYQiylk80y2i=o=t>^z@S9;7wfAh8&Y|^~qoY$A5-o~37Ot38KTmDgS`QCd
zt4txD=e23RA~j;0CILjN`Gy5eF0muCmcxl#Q#bEx#oGp6W<l-QT8yWdi!Ol_TB4UU
zz{jvoU9_=ocKyg`Q{${l?Q>d|-CLlPOQV3@T-VY9b<b_6i#A_++;OCbF{!(pCJm+|
zLX2-DE)M^?QlX$g@R-0-8ym7(j1w=azx0x(IXOtaZjNWp@mvU=qpgjz8fG_0;^lbK
z<Nb^rrxRh0<9QR>O-Q}zvzjh(q?VJ1_45*Q>Y%Wxb<HiU01LxPh_qx$(&ya!Ro?k|
z&xZM*_pIhw!gCYPJf4X><vc@pHglgv(Dr%HtgAlnIhtoTo)545yyqF7#XQ&X%;Kr$
zIh1F&D>xzq^NgO7TR!g@%2Up>fgPHgdG!7UrXf8$^7QBFA?_zUAMtG9*%Lo~>p73K
z37!s~<9WvU_YmUf*_CHod6nWH|HJ1!`||#(r{S)z7cY~~kM8+;@iXO*_?r0(j^8s6
zl_}?o-YUO$OFCC^0Df6#yNc&_o^@}0-g6Jn0-iFS&De=2@T`07^PVoAwS3>s6Xko+
zI^w+9JKs}}nm#*m<lJM1AL)AIS`+0}*`iM^&q%W2Wg^cn2_J6k(<ee+`r)SL^a(%s
zoKufhS2VmV$0B2ouF54lhW=vOtoo`m66H<J;_$jz@iP*~xK1U0#!<Dnj-6XKr=hMf
z5kHx4FTCQ@s?Io?z+-FAsMG%{<&cpQ@ssemuu4CLRuNiNb=Is4tJqiG`?oFlDq89j
zXmRu_RkOdi@O&6m$WdE?aFhpOn+1C?{$G_}=4*aZFAQFoBLol6gs+IOb!+y{BG<6P
zkDb!mfTq}3TR(4Vy)`XS^TNxfq6zdNmx5C(YHMdSw$@IaH*fe+jrEt*`fj>uPMr26
zy{G5$jBav_Q#LJ>X6Rd^O#I;$P9vIKPj`B0Z6;Cm?4ynpiHKGV17{?LmrtpiR_iIQ
zwr=Xw`WEYP9fI=UKh{_Y0MUh}U0Ms#<e?(!@!8eq*M@)oQ;0kN!Kq)H{kMN@C+5C4
zJbdctQw!p!o>b7#IK7~;uCc&tifH|brY5w583kEYT0Q=B6ryQT!0QX9*Uf6FFYro7
zbCcoEMggdUWM|5tx<*td^g8K{xvY${d+EUit&JBoHeJ$~O_3dnpnbKFIC{_(2T1|z
zony9~26WJ=Gwamjp)?+J*+DrF2r9^Ak{z|=jde1rK5AC|oVoQm>}>06VE-*W<xI+C
zo*(qv(sM0OX&?Vg`2Y61g|hPVoPhfXo=djSr{=+x|NYr^TYCC^V@uB;n4!!(V|U)t
zb3D&(ef%@w|J(1wC@VkDU2%WB)0Uo(ihKL#$N7LoLwoMNrRV#=oq4X<bxThx&!K(%
zGvWW+@9C74pXbTAcjEaK+g9@Z^S^fnw(<kE^b7&+uX=`k>+8kK<TG`@uNOa4{`>oU
zz4(Hog6#yEa=z%T@=s)=>}9Wg_LWan+1HDg$?GPr2h4nb**jDIE?+Z$!I3`vtMgX*
z#V5FD0`E4SfG2w5mYxMXt9U9ac}8vNxrcYa6CJ&!XEM(so((+Z#Lt%-U()|f{nGwN
zp>!lu^ZEeg`{n)5)auzI%F5IMk=#;d1*8|m8L=ukY68;(+uCSDT!tRol(PkXMA*V0
zjDhg<IZd+}YBjbpme;7NHPJ-!hN;<s7?K(jm1MsEZ6kdyl?J6QvutP6H+@FzXW`Eu
z8Q0IrE7}$K#qnDjW;9aGOi3QTT*shpPD;WhL=uu@+sVc@i$bPOdNYG!zb#kg`xX@F
zK2-gDa5fZo_B$88{wlo9e|FtP^|fX}7&`1Y284aBTN$v`KWD5S|BhvA8{_Ru>gz7T
z(13-l9@B{*9&RHZJ$!apUN8=;1cS@z_4U)H)J?r8I;*LvSq8L>5hZT~8<n9XZ~Tfg
zXV;LHLEB#{WdH@)s>S%d1tTc<A8O;_<MIq*RgF_+lL6LgQD;+YYR(LY$)cqJTb>H&
zWvT(uXD}GPbgLA-Vi}w>=F~OMtZkT9aM=}yUv`DmA<UFhnwn<S7Km`rc?w#ZTIWoy
zFUXc#U^WyR?8q=7TdN+`rl4*bX4uv#1uYk2!JXDH7e%D80Bcr3-ISIBM&uV3OvRc|
zFlG9zOHo)zQk%`T1&;;{qqEQ*vB?y)OrPPi&5u*BK&(!+u0)a4m;Q44<}uFPIsC}x
zOC15#ChBJNkv3arwRQS3pSrHOA%5x^wVCmk*MIZk`+?ckdFK0^lb65)INVSx<-UFn
zgSY%aS^nq^m3wa0(Xu;M<$*D!ijgX|p4v-jSSTgGEPZF?>5(m$Qo!uY_+jW}2VOBO
zde{lkQ=1x537w93ya?e0Gk-dxd~IFpyn^1QQE!5uQQs)3R4dqzb9Tu63-*_O?DczC
zV1~@P5b}NnwY3)`N<}@jwFL*Bb@+j2;e}lqyA2-LoL$IqaQvAXRG+R9LUcOTYB5Q{
zFy%0(zWM)a?@OSgDz<j(4AtG4ng9U;L}?PhfJw|u7}Nks2#6A8kVy%n;fj#UWVqrr
z0s?A)poqvI5g7u424skWii!w=7z7an0R=HCA_^i`lAQPLI(51`O@sdb``24<z4gwb
z^PN+tYS*q^yLRo`Ro#penMrNL4OS2che9_7ljqG`x4T$$8{CbLakXh<2Gv>zvYv<^
ziD)g%oeYY_1qQM>7t4akJ>!<qu<Bw(eaDWAlM0(ZZtNtCx^bkhq`=lQwjboG*K;>s
zjFrI@vKognZ2XW(BfvP~Qy41{Mm}=~w-^FqgE7)aVKD(IiGbI5kqDzq$cBv`F=U*(
zwD~03%aY>K*x;dqDNX>v496bIU>a;#g&<yy(pEbe+1OFAD39cWKJ6ng7cLe9MAx&x
zZeu2meHbF9&|`ZS>)>Lh*l_>Y<F`N7eB9&AoM^y2BG*(Ig1V@USy7O|4~>{$E)J=#
zZr23Btr7?-BI-$&Z-m&i7~&#I6uuZYImV1HyKZS2mlz*E{ua_(bR!XjF_htFv`=h*
z$gLpHj0LkzaZjIJ5YkIQ)}w~5$s;D***Xq=e7y}45jn<6QTP(z4T0YK^G1vjTP~22
zWq*gbhSD<8txho_21^4NL0IVs40q375HyAAP5x=i36Wm0zanRNOuz_U(*6M6(G~_q
zDfWdR7a4ygarobF5DRKCnPa<%){qoh7TIr@fB109ODchQshOSC9?!B7(m-R|#~R@*
zvb_uY6>>%<wV_Bm_DC>*y$3&fX%xH=#@f3)5nH(lBD%(;(A?ktf)&uUvIq_b4|Z#u
zv>Vtuq`4z$@I%9fVIO8FG;~;gJ_SOC3>}papO8dqihU^zF87uUNgkshf5<qo<QANW
zX>Y<r>={HSw*If>PiW1$m^%qH;>pOk;1rG*T`^|tm{@BZTJnlyFp)xNL)^+EdK?-s
zo+K#dSJ7UNe?kMs5($)O0^;8AVW_DV`S$I-pJ>>4O1pP$tjv-Z+3n0?oHSyH>yZ)I
zJTT1xbR3;a_J({<XuEsw$;>p~+7WecV|IX!-*9A^^PL$S^5*z&@$XZ;)r?+bP9Q#E
zn>|9ENV_Aj3$RY!yBL&HZUPUJMWDQt`VjVfu^CKWJ(V*_O4Y%{KwCcI@?YP0*9|HZ
ztO>`@57qmyErJ=?<(>oF`rz3RA?c4B0Tmr1_%i1c>M+wMk_|LjBzmHip5kJXK?UeB
zYoejPdq`|a$_+@Y1F#cku6De{VdW3>VWC#V7RRGu06kSmi4i|Tq;zHMjdp1*!sD&N
zo@lpFHm~OXy}GX3ZfXtA3{X8n1Y)0B?8d`YsV&&QSCgp+U8UX)n>Y^33a@t4PNv+8
zuH6r&K&TwX8N4X!K(Wp=`_qLTHlZZKCCBsze||j88rZWRBSt48fYOzSfuar@JyDo(
zOn)QBJu+hWDB7A8p7i*bKv>3Mv~i9>Kuf$4Luhl?lDTVQJ{DeZJTN~#3T43vpuP2R
z=qX{Fyqy+^j#g;H;{tm_juzX{9x+ltexhke@e=%F`jZv}((dVAx5#N?gbS@6H#Q$z
z6JS*eThNIM%q$o}TdcByt|24AtSiaG^LVV0B8Mel_8FKI<4TQjwS6GQ6*(-C5|U$F
zDfmYTw9ZI~i>K7KF|K(0^Q4Nxu?ZqMk&>-!v57IR*n|gg91&L+a=K_rwPY;?1V0ug
zdJ?tR5}oK!Pku`igo}2qTE}2&ps>DNb6ZU{mC)Tca?~&;-5E?P;*^TDMc<xIbI@)l
z^_VobW*^G}E#dqQ#U?W8o=^=e{7IG;A<=anhp@e?rP$8)o%gVCG%IS~-o$8mVx#kj
z2}G__uWnsjy|G#tI<~--S%8gK!RFn9IcmgUYzUE?9!-aIVq9@?apW3}CVyV2gB7>Q
zrT4jRZ;rX|#>crx<wlOBP=(Nc_mLO4b`-Hdhgc_Q+T%Nq=G79K0$*Y5c%Ne`t~(%-
z8ysQ@49vhOp~+(>QvcAbfk_}Y${c1RTpcav<F@e=M#tsdk$b1B=Qyua5-3g=;7v@R
zC$BZ-4xu73-r4hTYGtfQ95G>7oU7MZ%>C|gQJ}Z0NX@kN`J}xPCnlgxSn<2^uuy`E
z5V!EHCA-4|9~EA!n2kwvXx2FRsPY7c*`ZR?yu35%U|U>UQ;x7HRDs*aCby}%=pB#m
z1bqw)Ko?|MdsnUz<KeZC0isx%<+Z!Fws7!b$e8gkQDeu+h>Y2Pp5<|3ygOzy*x$~V
zZ~j!%U;K*|zK6aQA4nAq9E`bOaNgL_kY+6kp8UzQV5#+vIG}ZOjH~uy+T_gtUw3{K
z>M8ec2ljx^IMDsnXABks1EosExWr5O1hdrzgNRJ>z=0Uvc(&d=fXjPD@4tGBUz8=b
z|C?3apdQ)2|DhILTalzsfeLDXTWBN<N)RtZV564Y+|rQcW&8i@Wd4WB|CcMKdPTFq
zIW@-p+|q2C``L`=c;3rrO8}Mf#v!pi0zl+tSg`{dskCy#%52EQhw|X8(6JqJ>(V`V
zo4c3)hzZmV4<V9)UDLq8P7`30u@b>VAbpteSdUpY2nX$GT|u!FcnK3GdtS&r@bR7$
zvNoP4bC6rDVeC)*0%Ui5<MU161HdnUErIiZWAT}a`=$fqAF)a_#mzu`aKwzc6LIgc
zgVwnsb5B=zVB%O2PBJ2rV)|U;$4?w#PKbY}oHf@`ORR&BeWXm$o!;xyvBQKLF&tuZ
z%gV|!{x281Xa}Y)%)BN|Oog8K$@qz4XMQAhuP0-o5Rq50u*W3ZyH_uA-^dV)_`FZ=
zh#(&=E3b(+h?xMT{-PWO@@Rn#ufjXP7mc`{s87xggW)_58HQ!Vc)yjo-@5tqTkZyx
zS$vvGG#HwTy$E!Q-|Eb^dGl)pB*{6VZ45tTn0uKj7v2=pG2@u+T{xZr5kR<ff-?^e
z+?cU0tCwTF;#9<!2)JOWY`t&a-dsJmZ*Ng(-=6x~ck+_4Sh#s&pT|w#C5TdV3H@y?
zb|ot}I6z85sC91mT7HNN$_BL?IaXFrjdPzOw2JsPQ3L|4mzFSxn}@=wN8CpTWg4v-
zCXVrvlO+k#2c@ajVGtaUHVR|AU#T(*aNiIA^?M004>%eg;xoYHV8)iMuQIBDCxP)H
zj3vEZWn2Pg1GhUFt9ql#=v{}g-|&OOJL@vmaYL1HsvhV8dxSCeJa8xQA~3!IV=XpT
z8S8)}fyoUSTfP<ffPVt>f%lbH8S{aIffs-!K)n%T>w($8pMlAZ8H;%f^};|c0G0w*
zZL2aeBJiI`?Wi(}fTw_mfbsZGK_YI#p%>sL;E@lij4L-IM))D>X$Jm*@h-+@?W{6#
zAe@hZ=YY14s*K@?LG1!g0iFX^0ekF1{uX$@r^?s?><bLVys`$E-3syqCL<~v{t4a#
z+W-rq5!(aq26hLQz_9J!TV)(?1Ac&)fJ63G87ppOtOytp!<g&SDq|mT5HK&6vDLs?
z@Ix;HuK+XmLteKrwi0+8$Uj3pFw_;m9YAMAl@XSJ&i)*~`U}hfh9)wWaRl-Lo&#ni
zA?A0q$|wV#1s(zR{|fz+%vj<v@R7n;XTr9SAFvAe9B@!O#$E;nw`c5K;1OV}<5fn#
z4%i$4vW{pUa5%8Z*Wmwl=mXGo2V)I!R-g!Y=}eUoeJ5jU&x0Reef(NgOgiepuY&Cc
zUczrm?(W1`;FT&Pw=-k6{fYkWg1tN7Xy9UCG4KqKWiVFvYL&4Bn1Ok06R-{DvI2OZ
zv+?8K#aZ+}9^srSFiypJ)UJ#@3fvCd4y6ArWIwPNSfJs&EA+Ws$C+1*hbzE+KnKUU
zNMIW95-=O+z&ObRMgR+d@xUX%B1*^qO0XMPiQifX!*6r+!+-768+Zg*2CTdlXJRp~
z`o-Z~EigO@?=h|llB<nijH^;$G_V}l5qJfd1I)wM84m#q@D0V$;B$AoYU3O*tpm>d
zgd!hsH1J4AoZSTOz8&oWmfwN%oxoE3cRSe_rv;s=jpIN^7o6k8crDMUHiiQ$Gm#HC
z3%?eYTOWMk2O`%2XFXVLQ~~?tA|J+c!4Q-OI);KC#&aHU0&v!_YGWrbdm`$`_&ov)
z$GFYIS6>GaP6j>TmB&Djo~KkBq2ZwOIO+rDJq7sy(_VmlFwV<yo_7hbbQRhO%v*zY
zHbMEdIP(k4rn9aX|CPYe!02+ET?M9ng8DH2OMxqZj=d-k%mXIF4pbh6T!49BRU2o>
zE&#6p(~d#@un*y1R~z}jY~Xa@ES#MUg}tc!75oDW{zSWBH?CAw8}otD)!-Z054aCF
zE40SQgB=NX)fhVL#_p6FV+k<4EzVg*fv+^26#=HTuQApE9ldLeY}k`LU_LOdPmOVf
zo`Es2FQveAU^%ciFuHGzF$K5~xDdD-xDHqe+yM-~zs5KYj0Ro+<^gkIpJo9k0Ly{1
zfR(@!U}?V^qXHP+AK%c1-AWr!V;lkI0WSe(0UfYk<v{w8{Yqdu&@rgSC<aD9P-C2;
z_k(c`rZxDQRAZC_^B%1+&H!ftuK<q#L))M{umx~;0r&wPnOtMU!~TUoR%2`@oKj;X
z!~R|QH_8KdPsbS?*uhy(;k*qndj{$QI%a}i9QX%z1THLs9DuXt)ff@5i$`8WI|*M#
zJAm1*g5P+&2Oa^Iu7!MI9}8YX`+<(5HAXb-W5FrN5xDzIjWGyzaTdO5tivuY`~md<
z9Y5g=5HK8g99RiVP67R&Ym5TmEZ}_L6<|3q?|hAM2pEl@n(Lj4a+e@?VDuj-*B0-A
zdB9TOEa1ZbKu^+ue<D9H?<(X3tOPEh=PJ}s?}3%TYy)}&yIiRl#&%$~Y8WkGmuCUf
zfzg^_<kK^73GfQ=0&t;@bl7c&4dsAG0#FWidsc{HOaYbyOMrP!!#DywQpYeHw}XCN
z!$<=z1Qr5!1D60Dt&tA<UXGu;T>-o@0`<eb_j|}Nb^vFMGK`FLyq{wjr+`O*mw;D*
z4%qwfxdzTrLH~ehz<$6SU;!`>m{*K)z}>(w%nOykXkhj{!zch2084<Sz;a;pbB1va
zxbS(y*o66F)_lVV$NZ4?vSC~SR+bt@aVF@lHH>}0E5P6^(0Ri!N`c`U@wI5o6WPEB
z;O@<aF&*eAH;hBTw6_eSV>as9i~K;k!c1VwzwTp7L8#I+*zPD+;QJsw0-x-Kn7c4H
zFlT6%GrW79phq2r?9L_~+9b7zq@q+Ftg*7?RfdBS<OTE12H|rBa~?!3E=tSCrv>Ie
zB1speO~=QDGz<}OQQAU$IwCE=OcMFl;XVy%;a+JwaG!xRyG(<6u|xQzBW)n1b#{i%
zRy#Yxi?mKo*9^UrGkO}&aK=9o=!`}}CucY^bapyAVV<M*hNA74;Ae`)b#jJIQwIb(
z9hpI$oDN2`={G>AzNwOSkqQzsi1svH9UkZm&k*Fg2X(?d%1hFW#622i7ozOHfUJiz
zbT08VN9*i#&DJ|Rql<VaXZ#FXCuiC;dxkStb0~q%G$es#WI<Mw)2tw<HlyEw-3R|+
z7}3IuIYetV(JIn2oY6Cg)-;<s8qLh`D%=&#6z#Zza#ip<CgPdO*J?+WyB*nH?Z}|A
zBqO?%f93QL8e?C)@=3;;T6&X%cceS68uT56sNaU(2mQI~z0}q$KW**lEDX?EHTK(B
zQ725QxV-92@YIRY)9f>BMSQkCN1Ll6C+TD|KKGPV84b`*{dbZWbQzxu$S}WIwK0q`
z3cmdHK?e0fS7*Lf=D!a*2j!x8M-BbZyxQ2No3yUe2lLPenO=R+El8UQvbEB(g497i
zNu7dd9F(Ar#b`%5?iuvSkNj^c^pd{|*+~AYQKmOgSJ8ISzZkwkPx0#vNGDlrZwWt+
z<ntqpDe_!1PP#hd`-7`4UgM;55UG@RN=A_S8j`#RQ`ew-d@^+>-66i{^6JMSPq=x9
zzVaD*kv3bU{-Zu`OZ^Ab`-4ARH15kF>*1}cjpme)?F^lv_QuFG?Z`g7E5JLrnBpS&
zokH3Kq|w-A|8RzqChSDtmmqB{Q0Lced$FSK^l4bPplG6l%c~75|Lti*v0^m>d8i%n
z_)K30KcD3MDkd>pJ@Cm!zZON~`(u>83F$%?GyT|uyG(mfrl`mK4v|hle#S>#FP_Sj
z>x_>Q$oDdM(eE(%%Ef)C4bQFd|0jYkzcvcCQ`)HR&U6+1?8iiP4N}+oebFh1`fvj3
zD8bLZkHtOd^bA!UNS#PJS&VmwQ2)^D)$eU1bJP`ntAVzW+>e9Sl{WCPac_=+3>pKl
zhtqVZw)$Y8P;ApmX9fwo7>bExI@UV}Wf?gpFn-;0N4h%1M=kCO61v?3Wus%@yHi=w
zt}Y?AjM-X|uAT_Qyh?Knje!Zsci}Jck&cY!urIM#3*uhi2o1ijy^?cAj(R`jfgZYM
z$`CrY9rS1o_de;|Ll!-ub7-HOgSxr<_bz9;HjwP!wFEQ$jf16+dB#Dyx5`=LpcTeJ
zcWR3!Mx&5-4*F>RZTMav@nko7k}^j>&Cu0}n2XSE%%jk%Kb+xN;@-4h(3#5kYGV!Q
zia*(SbTtFE{7(P2JS!*%#gBlG9*J0A6CcmQsRg}j>>=o>(|r0qGe~{pnk2ur?(u(l
z<a3R!>-{p~*(94N)QxL6K1<;IRD!1$V8guH=jkgb@eEt0^cU2n&b;o<{QI4Go!~qa
z`EP7?keVy9^>OBPcIKL6PKPt*!diXW->D~G>!A7_blE|qvpJwO9P9dFWQ0YZVBYce
zaYUbVA)fDY7Ao3O|9oOZnRYTCeLTIp)Y<x2gb14dJ)I>zr2jx&Us`3*jG`aIA_rG8
zK1Wc`xx1<j`l(y}B+^ljw@*Y}51ZzK1u^XfJSiH>ba~AMFBN$Au|7j9LVZ*(+31g#
zAU*`tUo`8bv<ldQ`8^QNq4c>{z0yv_KkRlQvmp={^3df~UvuyJs5YuA8lP>b3rj?%
zXPb3V+BwiDM_u>h-n38I&hTj(v<TiXH49EI*(j1nC3No`@-`-U1Y3N0d|i^q5N~;a
zL8?0p`SVeCC*12l6D9ab_@qHEw%?67R$Zi@M!K+%Jwj}q=W0FX=sjoiBHJ{(7Ny38
zY9UG-(+cclGP6hzNKSNlwL9Tax157*p)fXTk!?1gqtC^(>h}NIfR7HadHPk84;S90
zqh0sFzwd{8y^+-}k8ebIh9l2Z<RLlf2FeOu=;rpHLXn;p!q^t%0f@E`k3I0P5V5Bx
zDGloY^d97SAO2<q^~B$9L2#@c-Gg#4*@aOaT(#F-&QPKqfzLyroerdn(n>*lzE6GI
zkyidU>mwQy@Oi+CZVx;&#OL(E)y7rmsX4a%`NLv<>F&IsXqo;8KW0yJyi(k66XI>t
zZb(o1*Tsr<!2kFsH5BbG0liCz(+$BhUBvSyq~#2+HWp9<`bPTQu#0l-1Ld4%>j$gs
zz4XZp>f@8r4V4f*9k!|j^aj8Nm@@FOS;FVYGVN@MqOJAMvyed!NUQ+eveDJXUeML|
zA}}LtmOr^lIY6#I`ll)6K)OYjm;Sd#U&=KXdc}LPMLyE4WPCPYzC{>=>65?%E^6xq
z@N@?8%*Wkr?ONMDd;F`e)Zd}nb&S2Fmkz}Wn+~7HP45P>D^s-3{kK!dE*mt9L2px0
zweju^^+(Jfv_8Ae8u_juqIDd!qUTl{^z(^cec+itz1y0ruJqeda0VO8qG7j27grly
zVNbkhdDiY?UXy-UI-C|iZgF;yR&zaZPVrl!yYTHNpwH3~W1feq^^NhO{vuV_EOKK<
zx>xJq)rCBCdFcut=h2mT?>V9Z^WZ;_SAQ5Zai!sN3Uy6DU3Xw!66uy7n>AOPqtE79
z!c70E#DzWtBmI?X`L(2TrI5{8(5!>L(?^*!bC8}K%2+ObE5lI_>5Gvr#)FTZc;wgB
zS*B^b{R`@P^Fi}}dfHf~U1vNDz<Br(K8}zf_@Z%@gZ3U;Z`v2VdxDg$HUFx2xn+xy
zNNt=Bxm3N1{Wsj}k;spW=qv=CD$scV_j*H%j+ifLs_gDdXCKLTg`{&HGQmZ3Nd95?
z?TlR9>))EPDpJMVLv%8I>4ah21zU99HtEnfFRcrDpz|o%_t#B2-tnf)+VQ5Y&I(n1
z89Incd=?LW*Owc{dgNW9`p7#R^^^VC2|3Y!xud^m@`WT}(<eZXq1&sCNtA#q6rWj0
zn}W1qBE?Kwg0v$@>o3!Cfn`W*@lLgIz&)nXSJJ<{rcF8OT))GrTaY>wFS4#_YgZ9-
z32T7);9VJGK%MFM6hNNak#;9+yZ+5>(tpVcvB`09w-^^a$bDHz?n@`d92wgET3qOa
zIDbCOh%s&%Uf+i~0vXOn{rX(gi7SWhF^=;0z>kBUqSJ<f7*9SvvA1nI#kCE(UrAhV
zJnebJ&71QS_vv4Bf#}}~@K#LxwDj;+0^XAGL$h<Cm-<Z>Z_wX4nt!`n!L?ib^LD-1
zU#u5z71!g9bgzhbdpiz)&2`SXhOpz<JDcL3TRbuoy5q4y8CaXBll+c{E+U4J)(G+K
z<JE?sF5*x_L>!8Azc=3H`*}xww*&i<)A24AsK=r7U-<?lsut<r=enM65Hi}+cO|}K
z)9Sl;$Vd1FM`KAmLazqlW%w`E#<O+6+a9F<6>o*=f7NgK=ffV}3a`i8LF^?6-X@s5
z4FZ2xz*}%lwec#(rat^eyh&dbytTZZuc7IhvsmrxoTZ|lRbkiHp^inUcLz{+n)Q+&
z?rID%Kvu1APivNG6g86j0m(=TMPIkT?<!EdOg|SRWLA6Kn64?{!-c5;#SzBn669yy
zI0W;s<<F&0^I11mg0EcErLP2iT;$u7gRd&oD|{QVm(as)2d~*n$kFOtPZUH;Zvq?F
zpvIW$wyFMnRUy}VojF>le_D5mI7$h|*z|_j?*o52H{~Jc9e=TZ%sURPae!ajL`z<O
zb~ARAM^+V%>)56+$m}ihLteTSRLpqHIkdC<wi@F;N)UbxeBWsl4^+EY>)#%D6^1~}
z1?1aL`5;?=aiC#7F`q6$>SI1hVtkU03<teCFh}<!dKgnuKTz*99fhP`&>oY#MK-8A
zTY_?F_zj5WR8C%GU#3I0M6Va_^<!;lt?5$laXM%otw5P%lxZjPQ`#A%<suC(hqy@p
zsDB0_?GfDTi$O!^HW3;UXaxeOE*A#D3gm;#&3Xny{n0X_+Y#@s;GLz<l$L|Eumt=b
z2j#~_m<+kQkQRk|JqdN)?F^+gFy${q{$#wPbvs?8;lq(X9%<M)LQD|(Ju(yfY!nsg
zBDdD8y1o3}1`m1k0}`$sgXxd4d^6GA+8TdNKSRF>H(opwU*Sj#Mw)2}%>IZ$S~SwA
z9i$g`p$)`u2GY}!zJbyOub5Y4oLPO|-NEj?x1ErE1@adnyWSRj__R;O(p73gr=UUB
zt*OIQg;!gfkGw%!i!cUqsE%XNR7~vC(s`3ZsGI)t6a6!!qwZ_=tuPNxvvqZ117uO4
zGalQC5Ial)vci64`HTI&GQz_L_CRbic#%F^n`7G6c+{N(Uf>#FU10J;dNBnZ(GR~}
z(h~RPUQRzThm!mk;@xPx!!#)_%D)b21%C3=yWMzKgm+@Bc<l?(_}c^>D<N9c=3j5Q
zM&9ID-|HuqbqbZQMZARg(RZU9E}}>JlAly#G$nfFf1h4F2K7HIdUH*B9YL=*=?{LJ
zW-8gMCro<R*c`0%v<g_>S{rSdBIY_D<%?5mjKi?KdKa_&Tvhlsp7p7>KUk=#Kl?Sg
znf~^YK7vnf%}s^ZTU#y1Uee<v52_y*_3|JW{P!L;#`}~ohW2^jt54JJhPWpStwy{t
z>%(29|Bt*=?)LPzuzyIKg*4J(il?a<aMTx@kiG-ya8txZHhZ^=;)^xL7nJh%ZT3_j
zfeM>VeNqX1>TwTjCbj83%>GdRYx*PuJ77>83NyiWo5KTMs~?;6<WP?c)2%H+Y9rZ?
zGmxFov4@41A=cq}%@Dsp`qOx?53E&xHtmaGP|`VubahN^jmSX$6)0N*-tQ#dqs+42
zV;l=Sc|HK!BI=VE;z;ox;)uSRqqLT-d1r{H4f$R}T+CJRsCP5?rP)@0M~rAOR^naI
z@18ZrZ<M|s>5x(p>47{mk>SiyKlL7a=m9_S>*Q5;j;~G6L%s8f{{3dXdAKh{y~k1S
zK^jw(j(VjZBF4luYsGxpfKS6H@mc<61!)1~e`j9vhQf#b<n%(Wx179=CQyHqoO*!Y
z4nX~++0q=`_iK*%=Dr$ZCrA2er2FuDjZassXo2L2UAtfxdncq<ba~Ac)q_2J!A5&A
zhJ3_ZGCt=JBe@HxFEe=~I+ws(`u#P=Ta>;S>B4t{#?#(Gt~%MAtuUCO`;?zf22~*c
zCdxnFCx5y+&Yi!DnZGyk=i*GC$bZ+3^OIg~LY522KOgtCcu7}BxoLx!Y`iW5?cq2l
z_>B%;{=m!)x%wXqU7ZN+PDWSzjt1d}x<HH0R5yZr$dA)2K&umqcnt)q&xPbOIA8cP
z)wlhBufEYJei{3MqP`cdt&jAk7|Fwj!baLq-;-v2-g@q%H;An%+E)MTNf8SO1I-*4
zW1phlT-@sqf+jAis|vT-c{Rpms%yaiOkLYujJ<Ewb-SmoJoNGLG4MM{j_s_vd}4;4
zIjuX^bJ`ec*R|t8#FqVxho1*|jfd;4MV|t1d(n3N3_2ed(a~W}%ErOI(*04S3!8@V
zAZ;4<gQfeH5k&G_5r{K*(3?9b{|1vz8t!|5PATX#vm<>a(#5#KnE@G7$}F;FU{6fb
z<3dLxq=a>sxg$n2X^rw5c>7gB*|$xaXb*EiZWC}mmDVo$cP4Mr7ZC9mkKGgd#$BEL
zx;b<2a`wZ4vtiDDonVc7`89)N>}c%K<z-V|8R(H=j<-o69?90F!`6}R=tE5&X>QHH
zlvDy9=fJtv@Aqmq_5w5K=-p=Xdqp%YOs58S4bl>CMp*4Om0~SKmkvRtf$l}JmCH<>
z>4EempnGH$&Zd$)AA=xnY(p^?RGPm1sEps3=Q{&DZ7sW=zRX{V?+AbwJqh*WqPEj_
zEXvl`7~M&i<1D_etIJpuE7}DAwq2Z~@}tYmy?Cp*o^3AyZx4VUeTQe9Re-nQ8)}UA
zG^D?IopFXSCC~hHb)HhRSc=VGJI;jtpjOkF>v^baDb+O>G&`Y`w{jqzbg2ja*j7~;
z<0;=0A|HH2Ij^Lv4_Q89GTzhoQl@OGF@j0o?>G7Mj<a-yD}>;<%UsA~nF2|rqg)xv
z_1;`#JWS=H&2oPHxI#tKu63?ap7^B8OXoND^XNgL_jxZ`hmg*%MB9%7^)F1F$F1;j
zN8bv)-BM#fZN)`nAqUI9WTfrHz5X%sLubADbNhMoeLPhRNE!?D{U;}67)s@f&HB=D
zUkbYGK({ZoyU?WTf8J9oOv>&Bp74RGE%e=<-COb7khmw?G)<i()@Lp}I<PE1hj&A9
zug8MEcn?<q>qCl!Qu#qBpH^ODjKn?s_jvNKD0VOfj|F&Fgm<KOe#fcMIqMvz`lVl^
zgwrhktyPyGt&aamjuzqBsPYQx-?t6t(IFqd=iEGV3!TO7O2hG5=di0-e}$o6^WUj4
z0?-!ymgcfOKI<>f7y><YFUVcH{m|L3-<{dlqi?z1!^pC+HzO7#=9Uj#XpE_YM_^me
zy(i;9VqOtzudYrPEM9n55#qTk2x$nUz;hF44uWA|ub>Q#H(GDyqPsGJD9V9He5%mS
z@EtYAccfF}U80?HXq`EmV*5pOwt5Dgt)6CsSFiPj$b4NXzvsqA^zpPW$IG2^uPde?
zW+P$;^-w1+8aL(Ob;|qrEnZ5v%kP+pR}a@-8)2=v?^9&Q^ug$RX&pbP5p%maf2+@;
zx$sEMI7=n;;~d`q3(xv;EU1JGRXWBY&O~Ec61E}zHpu3~8ezlCJi>lqMJOYC5H2|&
zROe{qU5LB@IbLug0fq{pJE4<Bcu|V?YgD}VH+Ol)gxH^0<yR*&yyDB=XZo?D;jKKV
zf@}tw$>I>32?o+dV<QYktm2~@gZ^VoFFt(sZ^YOXeE8pF>muSr@sM+i-S|EaNa+t^
zQ7z;MouRdZOU<!tybJH?^0Kpc_wwk4YnnF0eYWWt#86zwt2YEaTx4r@gXaj;lS&Eq
zlC2sp^p@Ip2Jh1G?j?FB>?`UoqWW>Z@F5Hbq+!Mo@j0^h^j*X<<fpmP<X4WJc(t2*
zeE~a0cCi@a><scgf_weBn*@FD`0fO^FW5O~l;sv8FOA&_#FtLMkIAF5527rtbbQW$
zCfkGW+yL~x7EQ5crT}doNSfa=$POZY%==D3*km(rT_{JFmn{Etua_*n&j9SQ{IkoX
zp|bxI;YXtW|J^gV>7W-6*=KxGW6*y}slSXmeC9XU42ol5H9LytU!O<{_yCOwpfLt~
z-iLerU!c(m`K=%d(mLX^5P8;pT4TIH^$e|54`{m2?iMT9)bp){`hx7`Ak+al;XE|T
z<8tA10d(~PH3r-yrYDNJp<8`1ZgH9m8b-E~zMC3~Jg?*4%Lb5scXjJaRuHBtS{A?{
z$aQZI=-Dik8%y@|D>(F!jntj4aK!&K^FuQ+*OMMkLH^yJ%lxnV=GW{HpnKgx`PU)8
z<B%CY)2G(TFXHGhW-@<wu}<lMy{xs?I%NRz<D#+E0*wp>ohV8WJm!kAm4iq6o^A`g
zqy11l$*kiB>rbrHH0^;vzlQ62>$J?C9^EazUi>j0e7~cEhtEvDiMMs&ZTF8g#_GCA
zA7<*r4dSBRorRj#I>;|??zOQC`;SvGADw`0)T7KXOLc`q2ZHhawgk+PdQWrA-armr
zorQMonPz_Lx?cR|_Io^XD75?7a?)Ya#hvgyw*-KP$);`Wh_p@Mt*n({e%GTT<}#l#
zD11!PxXwO4CL$l?&(q~)OE%x_;UmWyhEzZ4+@JWa{V1URy{G<UFjjnvVYDKdQMyn4
z(gu_$G_GpJx4Zk>Ye?~`zr@=P5Dyrx>?C-2gvQjHCJ)p<<=~+szVFutYi|9t$-@o$
zr@OO)Yai4_|6tDbi3ke+nA%F0mt2<i@W`d&dgl_#@EZhl{$JmVe!vxq&-AvK3+~2u
z_C$)Awh(E@k%lQkT-3I8NUKDei&9|f@5d;l^qok*;3xe!(y#bQzl3ylPi;C74;zF(
z4y2#My&mN9wnxHVP^@+{)>v4%!j8c%K@xuSWA<GhIb0K~ZLy`wz%~WbH=FIJ{+f=7
zv=H_7#=U7@#9RmaIo55Vx&`5^vRSK;SvktALz%`@1{d+a1e1R`(jLIQKG@WA?=>R2
z@*iLy4w{>NA-~<Q{mVDw_hm>w$C`XmyCT}bet;g9Qr><5=99jb3oXiLAYTRYQCrv`
zr>htGh3@IM2P%>ND5axH_uAG)-_sx_Fc;iIPPlnXWA#)D+S1c79wPl6Z?<7Jo%Qqn
z{vw@xY(&!~x&^Jla1x#2r!SQ5p1#QU9jgb?7gR=%GTZFJeJ*5p66xdz>h&!dit}fv
z%$yUaBaepPzz}(^nqx_xQ4@KHW;FWeINBj}NshN7m5wWxVShQ(>A+eC<izDQhWdB&
z@EdQPohP5{ICw%gF}=hyri)NVUXEduk-eM$mtz_MUR`Ty_iJ;n7gyPXHd=dMCHi%2
z?jztWk^1XJlecv68I8W51sR<so@d>NHwvNeyT-`Cmax&Fk=EZZUdI|=AABPk;%o-R
zW+(>Y$7K24*ZaAvr){Tv*9KvzpT^W$v|*Tz`e&MLgUDGj6g6j<VT?nY&G8B)l>6OU
z6K^l1i+lW{yM>>YkFxWJ8^%*8N@b-D_N*<$8b?JzpD(>4dk#K@?cpDz{1e2}W=kgG
ze3`$!&I}6bSAwOqYZvcg|0ag`z~!ZbUu1dYg89Y&KFRNIOMUER%7w;mL<iW5Ji}N<
zcBG5Ro1a)tj>de)Zl>_RMq^(11a!xPmL6%+4afb8+c76RY?yo7kXe!Xpzyy)M~YEr
z3%q-j{9e_PhtK&P&$^K;M`sepwbPpE16DM_?~i~7j6?Xnrhh|va0T^r9Ag-X)V4jQ
ze^YxOFI|1r+qlAGA{{yhWAG;EWfHwIlOFM%4S~hv8^&!kZc0sh*Z5|FZ+WIVS49NO
zPcO=P(%|D2qn>(H&rq`-(w8#Sa|!jFCm--Ws~#Wuh**z|HI=E_^ESUViS;41DFPE%
zD(ZTb>KbO&m5%!!cOtGe)i8d=z3;flL40zWw|qJW6?i{lyGmS!p=52+kEy?QVY34G
zf4Z>ppsy4>EUeF;%wXFZaNKWe#DD0*_BOd<!^56v%C$5`B;7`trX`#S#S2j4<qBer
zxN$V)omfZc67GZYk+xA;r0i4aQ4ck<*tTo@d!15R_TkesmdlT;>;)?SgTk?@x}@+~
z8e5|x;Y+ojpk#Yp;WGr0uw0Ifh==(n3M-)^A1N4DAca4R8z_OdA?cyd)wggGj<Lth
zb}nwL1P5@ZmcrY!OuTo$5e0b(RfNk}TvxGupbS`|Qd#pd76&MlpRT{8--_SLQm>&O
z)(uGyM$J>%ex)(2ipp^dhJzdN+gTa}H4yLd98eFzsef~PI}s0h1e||hgQU^;@{dAA
zc2McBmHJPM(vAp}ia{pgYr3LLUa#JaUlRCTz4^r`_NmVC<0;SCUQw}S@mt*o{)l8t
z>Z>Osl{do%uZUu&8-^l%b~yh&QmJXoe~DBsHsMG))s)YSQkFF1o1&Dbn{$NIS4UEw
zb&-@_9!cptBPsu$NXq|JBnM?LStTf~8u4EOSX;h~v-|jZg+0zOqb%YxF_fn{_(u-q
zCkMaa@G2t|CX=O`3gc+PGuWNx{jK}dd7!;UZ@jG;`(1Z_*o<ut+yL8i(aGOz#!lAx
z07N&|Kd$3}B-Rq<gv8hkf=RAhB*YkI=WSU8@5vH*chU7DOj)OXqVggq`&qT&OFu7b
ze5#W@quXXW*#_M<&&jUX_*y4>%^tbZ$yNvQ#ZLBBVB}j)BA@jr|43!i6ke#Yg$lo{
zvJVwLRcA*PUahh73J+n^RgOM-LFH>z_KL<=X>6Ouztz|Qjc--i*BbvtBT5UDSqi@z
zg)-XyD7N4E?~76Folt%viX9B)hojg}p}ZuD&8*88MzNK3`SVfi3vvHmJ$^ZoovX*U
zMzQiRJ|l`<ZbbJVH0B$l*wMy(eH5G9grALKpEaSBc}@AW7VO&yz9)(uyNTCCvZFW0
zyocUyMwB;3a@78AByocN1U0bsn$n2h$I^Kw`-6tqG?gz^*+!MmQrWvI|4?PeRsN02
zW@!8m&X#EWH_k3={DjWt>nKyE^V1Lr-Coi87o5%Eyn?f}oUgF4y`1mX*j^id)6Rad
zA<I*CUT$Zv+i|<o&iB~ac{^Y1VACD^6^*^-pxhrj_=*5lDekKsd`AF#K7elvV9Nsd
zngHTg?`U?b!x~bQmgXmozM_YB-uXt{yAWDdqwudI*g>_)rx9$n#=nSQC(x`2wq0+q
zJ_6s^rMF80`9~3Kc@W<m!9I1W??kW}_3Gp8C-o@jxv&O5N3e^HDQ9(4^}7i6QUu+X
ziod9|VG=6;QX#E4r|^$eHdW>CiLre1S$(Otq9J=J5IIf;JJ&R1--rA_DGTaB$5A$<
zF`uchJ9rn?GfgDi^s>%BuZMx|{G=W$wV~YffNC8ndz}~|C;{toAL|HHd^bEhJl|BK
z@@ML@O`3CRUABf(0mr90Qs#&F7Qhl71#bO8r7t^wqu=~OE4Gn4SGHosAzvf!;(B~(
zD^^thXR!8Cqj@?WkX>h(k*L^ym44F&qjs7YwHI$@Uk7eNvFGb>`0v$q=%nl?^<UBP
z;8o0aP$`cR1nM>7ce9R|${!{Bu|&Zg@-^s+085c_6H0$iDhZp7TfFeKqG5BiY0i=)
zcDgR#k;D$wJLkd!@-?+T1yZkKlqzhulG1|hAgjMm{aHl?q6*4oee@_bh3@sn$V52O
zL~q3j%xDg?wm=zV<_Ix!1f{G+^G_@FpB3!sL00lcB>$w;f4){SZ1>~JxVz3nCckjL
zC6-;b4aDD70enF$TN}t%#VVhNJc#@0q5R!g_EOzE{Qa&ze?68R4m+;`UJ2*>W0eC<
z_^w!GwTr(TtL$sR=fo<%$I$(sG4$4mAwtt*DbLff^cK8WbK~7grwHCp=><L~a-5=^
zqwvj&vP|KJ6#OI!=33=5g*PXa-J-ImRlZAQ8&rN!Ro*87{-kpJ%!!*E$ttuhDZpN(
zKE!!}`ikTy#X$Fg?fDxjyPIqwy=i6Uu+3EXk3#-+8}V-VJ-KHTmcb`7@*t>x7T=`Q
zeM*5Y|Elo4T-n9xuUEa+9PfV)?l=&80}B+sE{Of2Ou;bJBA`P${SRd2HcEZLz7qE*
z0@Ahzv6ln+rXaQ_5FYOAAUJu{COZ#iEx-y*?^!0tdh^@Owl#aW7B){Ufx4g3_?`f^
zQRhbk*c@Abc#L-VxhL!m4+x7D>;jQQeD2_)(e6TDh(g~{q0T7eK*{rthF|+F6q|ks
zH7(b9c`*A;=R1PgF}@C}RN+8XF9$R%3uYGr@5PTb1~uFrESqsNBbB}#AL(`^Swv2R
z5RtPXAo2o;TnHG#*x|sm^C9d=5Qw}U-0*M+J0Bc@1XCi{kh*m&Kk9%Zw^8}P!G6=U
z0}fWGt8Y8-Z9R^ZcWj&K#UJ*@-#CawzyNUZw51_|aBh+42!#{X%Jcy49>y0rDMxh(
zD^>aa5VlI=2SeCL8vi<kEztRq5bD0~LRg`l{~W^h+rxfGx`RLEWFI*AGfw!mq0c$l
zwh&4I@jF9#JR=PuH{hRq64`?f750|G-&I%<>GSI<e^X`WRlZzfb2YNkd&GSGqqqkN
z9<v0BLX28-4f$W1az&ksfir-;sBj$Kcva<}44}DkO@FqW^YsI0_FFlCJ!eN9&pPnu
zf`flHfc+M50@S7k^RxZg-a7o~0QO}aerNz&UzZ=~&(7BEh`-zGA;|SXeZHZ;vbsU&
z`TlG{L(0CT(Ib}!u&Istv;k~sV}7+iJKvaJ?#~W21@%9gQI<8NWE-RS;r{GI3;yc>
zR^5XCFo5lE$%_XdN;>X^0qpBrm)o!tm^gCj0JbXmDKImqEq|#$`@L=GEaXfJJ<*^2
z+%CRm06R@{=Z=p2{r+t69eFr;aA#vMSDFr0Gdc~P*PpHLf($z|_$&R{Zy9_~f3|^q
zZ6lL^Gk|T*LO|t}Zv3tO%DeX<b=AE@r|Mn~!XNhLU}RliB!725@%roi^s@SXBuwo`
z&HlU}pD~b~?nk+&_NUx4`xB|6{*)0sTej?iqMT8}P%avu+xY{m7w^ZO!2QeQL2G+R
z*F-n3SNTSjy+b|zwaUMRC8FE?8vj9~kvm6Yb95xE#U!g^l7%{6qUUv-zine%Ie)>%
zexy0H*oLzSpV{~?Hujy3|7c@tsDn4#`P+8(72Uo-eZAJfPdL~P2R~_NM=9Z{0KPte
zl?H(BX90NriT=!_+5h=KzAzAeF5j=P&jb0Ff$SnB8-aX!5L-=FbXyQS08g6@C7B$Z
znJVAwWXDu~$_YO+;vm$W^J7l-QV{(;8cc8BcGCSWC*4DV>xA;f3P!^Mg*_<;VZ9X!
z4b-KOj)R5*hAuMd{ZN6h!LdqYC%(+ihQzG4vyW8%qMhy2w5@jKqNcrJC+$WGcr!0r
zF9pY<>_FJKM}YDTND^7TL)O}udMlpBS~mYoW&a@8@@>pNVt%+;3^P8IJ%CKp6~0el
zixj?0VVf2Hwn?Xd#CCCGO)>#A0xnA8g6{@OP&gt`FRQ1uCvEOo!=O1MnAg=>^ElSd
z<j>S3F~I9Q%;D}FS72g4(D0TdAt!lpPu3f04w@RMMtX1WA~2Y`K8p8Y8K(E5_k=;E
zyq3+teZ(-n(at8vZMD+^<UKpPs-+;|6z52xypf>M#he|&X_72bK2nz3*|+L8b&;Lz
z;T(NH`Dh{788bBQy+1lhmEKzh6?O_M+j(kQ0tPv$`)ZZ1h-I&7d{Zp@k<@!7=j&qG
zety%j7`EBQu{ZpUjqi(PXYKrWEcCbDp;&e$AOdgS4Lq)0jA4co%PjVDUHXMMqyEjM
zaTGPcmp&TspJLbt4f!*%thf=!`Ipjgj#8h8V|(pLV?H%jITgWQjbp2C;#INuJ_X9W
z+KhwX>1O<N46AO&=f$z-UHs`dw%)~`jAPF<N0yDv`AczZRV3dT%eF;P_AjFNxmdQf
zC9!?6W#d0%*g2BaE4T2M<JiyQ??=&y;vKz}Z;xf0VyLA%V)&(4wl9X4#j(RN#0!`g
z-EJ%{RS>Jt_-WFve_^Ppe21!?RryaUyR2dkysGi{bv94u_z8<uIzOOeeL(k@bqZrV
zX(NqXVB_D|*g6}>PeQ$K<CS*yrHy}JXV2RCK?i%q&R5yl20O=eXy;$p@uMtY_%!`_
z%E6Zgu*D8u;$Y<t{=0+i7i;B(WE{%rkHx6a>0(uxu2w4iw@7vcGfyPjqw}vL*?;tK
z90l9N!#|B=-*Em>B)i1<JCSUjjh7%iU{67w)dBo`bLChd<$ozC^4UmsGN^r7BzrT2
z&xmBlL->!8Y`2pyjAU!-Y*&!9vhE%Qd8gLrrIGB{`uy8Sb~TJjPiqia9LcI1(*52>
z^%h03Pr~W`R5(%EhQ&}MJJguhG-n?);g_4UX-&hQ!%DSj_%l)Lm!^Db6q_2s|BPhI
zA}F4)|0XJR=;kP@5;ItH_LhsEXwDWkr}P!giCS56;%<BMx=1<NoZ11Yn3u7*lhTfi
zVK4p=8;{Rpyij2W6#lJ(xCw_t{+Wi<C8X-5I;C#XIb6V_obTY$IAOr7(K_(od$Vl{
zU($yaV~q4+AFKbK--o@T^O?QbRL*DiVLP#a?ZqzI9xdv_b~*UAUL@41ec^BMnSI%!
zpvB6%KJ1wgzNruUDTJTsgQ3Dd?8RQMQ>47un-=x2_F|QF`OZG<a(%wN4_h5ps_gB>
zmNewA^<r}y@uPj%vBrE)A6C?)T$$UOJr}_b^kEkxcy%9!08M2d_Gz<n<@Y}9^XB|W
zFZO06KLvs<_}<=ZMa#p=w%+XUE&Rp4Y-==M)0=H=-Tz2$_Dh=vr~9yzw>CJ~i!G1k
zr+TyHas21rY-1d+?9FE1##i)abK-l<?aQ_$G+5S`txs%lp$~g9ng8C4{glkt^kr9*
z`HH^mU<#kwo1IMM&-Y?ax1IcRFLoe}f7gp`Y{y^k%~rMNZ}w&t?I(ZOn=R<b7x!X+
zbmRwnvy#pvnIjn_&smuyy(5_<l9DWH|I=NGpHtna$yd5ljfFj_m4)|GlTO_$>bj5e
zl-@`5zq#)w<Uwy8R)nQr2v<vGD^y;gBC5mx(AYGMf{05szJRkgH9n8C(^z5I*nh<A
zeb&Z*ve9VV6v(#P`F1;7j_FwpyssSW!vOwqAUhhsPXw^<1Np{aRvpNv2BBX$e&oFj
z5r81}TrmGRn3V?e^}%d;2;UOIJ`LfYhp>%Ke#J?{=S&Fu+R0bdr+C$Z`fPC>{#6~e
zp$`9|4y&jG75pQVzgU;euFIdR%buyn*Vbbt_4vwq?8*9kMty2pow!cqAJ@a2xIo1$
zgru-g#Iwl6S@EplxHlH3D3MJN1${voRHU=5Dt}VvyH#GL@jq1#bzg_(lhUh?D`e;@
zu@*XxkFhvYNebn?IXq(Cp5MuOBF}n-?^Y1ACBGPhhOugeW6k=3%Hb#-p+JzEPzh+v
z7j!CBWsgepVU1F#m3FfiI{0(l><b{pZ2OVmwn$kPa!y&=&Az=pf45seO?~~%ZUMy&
zQt{%oMwIp2M!c$<ebLRyxL@9^S_PCwHiltriFSWZ4gReaKhupB-NNT~XUlKl=en`&
zxA2+WSyeQ@)Q!z=&5w6u&$W44+0%_}xRt-yoz>h*RlN{H<jZ5VW!(dg$HpJ%7O*Og
zQg+2rg+=lFbhdq8!hMUf+1W&nvTr2uKeO4fB>sCg`#70j$Y$Rq^U7>ioy_0JX8Tg;
z?H?&el-1en%`|=>o1I8&a5$S?Y{#c|W6!qd&vavZ+jG2K)gb~|XWmYgZM?lDDm!-v
zr59)Lt=TjH-pgh?Gn->Qo7wePHand)46>^3dJ{O&%#M0oM`yL5jYwRC(fAmPk1NV{
zg`(VugJe?gOvPNJ^4C=1{lRC__|ibc;IuP=N`+2(e^%#z=(M)0(%Bc}wZe6sZL=5J
z_)|9fDI4EqN7#X;B}`FU>@+A|x3elcf6`$;5x_45u+ud8T%|v=0{QGfwvb%Xjr3=C
zAXWAi-R=mY+bco*ch&wvFy9bj|23E&aN4Vb`P2~mx)8oS#J<mojNZ*-8Bklg2($5l
zj@t%2123NL^t#Ay>ZzX1?`sgq0v>lfZhzeNIEQew$Avzd9$Og7#^XbD(j-Pp3<aLM
zmFN^H%3XILyhJM%a%v0s3mUnTD>b%V;ooWOgu*}4D9Z7aPX6y^jeV$UziSLWz!w^O
zR^#}6yb^5$9Dg05_Z#pt9rcyqvk9M4i3=qb0tewk<2gZaa#BUK>r2`on1aDhEvFzh
z5b^L77H_VGz3=(${k|6>a@gyJi`5P?PgPojYMIjDnR@IyjN1Be<iifvW4ly-q8>Y~
z^0W2WGW-f2l1}RU_qyy!&NtOVbe<oqi<Jz2t{(dgvDf<SfP<f}$BF~_wEApD5P!Bl
zyA;It)@2*9VyMqP38nNOLgCu3sY@?6!-Umi@7JY5V1u8Mu6Ltb(TG(31jLLG>+_WQ
zu6*^Xl82{%@)sM>;`^sC_KCvJhOyrjeld)_q}D5JK<ly-VQigNqaxFLHhv(C{l~_S
zhOtlW@kp8DC{aELV|xPlzA!d7kSM(zxJdapj2#T(?}V|EU`l!;c#BdV#tN}x5XQcA
z^4G#xQ60W2j4g%nZNNSc<+B^074@!$vC?`RIp43xpK8FW>(N`Z<sHS&TO$yT|J(<$
zsE2tzdkFztg{@ThR)y_T_$w;=R^jLi%tF)Ab#NL~68J|pijfDiN*G|3Rl{y-?0JnZ
z)Ywi$mo-))b_C9A+|byc8lR~%1av>s**TrRstX^3v*$VO8o-I$gaL|9a<C#Be}l7y
zHojS`H?a)3YU3~1*-v(U!OoUA_*Mto2shG3u4AEC9^AZ6;eWuD1e5s7`7aK3&_?%P
zJLoUksM7)h*t9ujP<CERdy%u(bv~D~BQ$AL(;vJ>2rQh{$9+8F!((KT^v__Q%lYkC
z|5kJUy^XE5;Y|hoK@lv2f?2D&7?m=6)75a+POE8ab@r;pmt$#73#(#TgUH?j*-73g
zZu`dyWwkjR<hpCft<UHfSN1K+``EJxqCJk+f_veAWpPH}_W8QB#j&7XL;S4?;|HSH
z#Rf$hU>1eE<}~F;qu4fDsg*|z#W%rj?yv#dE6w;@NTuPn!(~>BJtKVg4xcC<EiA<o
zB0@}-=>K2;Pf6gQ*_w(2CYF6(yLGN?C>yT$LuPt$6vhXxoW16fBR|W0Z@$I3iM!0_
zvM<e){MXEUg))DM%wHh$S>?ienB{!a|L*%}`m&eT^?&L)TJr5xwYdGO`hD|T&!Mlu
znEZ_^|8M3i@yciRTy5f4x|(wH_pWx%+D|(&%@U`g|EncUIy*|uc2>yxE$Zb`-<W3V
zO@(Tr^*;ZB+VVMd9XhO=)Q9WPDfXem*7)Zq`!DE}`OtAmIu^e>e4f+S*5=>0{Z_gE
zX}sW5Z@knC-}=+6adaKI<@mJsulS75GW8?0wTZd3_33q8@X}AO<ZEs((4mLFak(~n
z^3|@%EL<tu=kFcm$lc;8PtPUtImgFdRmk*QpL8no-@3NeuGgZmLyoWF>x{FUU1m97
zyICmHEjne^vyZ)U$#h>m*dgV#<G3lQcshXZby=el$92SIJrDPJ9^><jeMfNxOBDY>
z3GPGW^Mplad$8^mSGJrl%x@W(XSL}C&bf%IpL~z4OmR6R{*JG0&~2_{8?KDFN@PZC
z_=xM26g!T5ip$l~#31>MWrw)jy^~YhUhb%4zNd3)bm2&$xEe_;7+~I5>G7H7v&AR<
z|5$Vdm>|CYLAN!A$$v!`^MxUwrB!1W<nxYB=KKH1=Unsg|Ns4eTmpqY<Jf9$YQA}w
zC9$u>krF3KoFQ?6#8ncvNZcjyu*9<xFH5xj)2yeV#8whhC1y$ND{-X6NfKvBTp)3k
z#4QqcNjxm^ti;O_ZR2G95?e`3m6#>5uf&lOCrO+kae>5D61Pa)CGoJtvl1^$w2hbb
zOKc@ERbrOJz7j`DoFs9E#03&pN!%iFm&C&o&q};3(KbQWFR_)xREb#<`$`-sagxLt
z5*J8ZC2@<yT@nvVJS*|CMB7AJzr<D&Qzd3e>??7k#7PooNL(OsmBcL)cS$@f@vOwl
z5^a-Y{SsSAOqG}=v9H9D5+_NVA#s7kRT8&I+$Hg_#Iq7FOSFkEnc)Adl-NpQs>Cdb
zeI<^RI7#9Ri3=pIlDI|UE{TUFo|Sl6qOCx-Ut%kXsS>j!_LVqN;v|VPBrcG+O5zrY
zyCfc#cvj+NiMGkIeu=Flrb^6`*jM66iIXJGkhnnNDv4Vp?vi*|;#rB8CEBnxNmoOO
ztt6&O%#zqw;z)^;B+ihyK;kNiCRO+ieXN<*O7V}D-(dMYmC{iNy~WI5GQ;$Y(mR`u
zLg9ji=8JEBH(ioX7U85nt}{Wsg{x9IiT*2FI65m2RT7qryC<BSgY<ueUK{`{+_mE0
zv#FBz$Nq+cs)+kMP>?wcl?-3~=9W`%qbi@)qdtCy#op?|OZOF@keHO5lG-+{-H@Tf
z@c%u#U)<n^+D7f7Hc@-1Ez}Ot2IAl1-4BiU`1pkQ#Q3E6<oJ~M)cCgXY4Pn6;u8`Q
z5)+aVk`q!AQWM%Hq$RXVj89BROiWBlOioNmOigT?n3mWsDLyG7DKRN2DLE-6DK)8W
zQd&~G<oM)-<izBp<mBX(<kaN0$!W>$QsPq*QW8^=Qj$|rQc_derlh5`ON~!WNKH&l
zN=;5pNli^{o0^u|u5EnVgtm!oliDV?O=+9jwr$(Aw(Zj5(-P7W(~{DX(^Aq>)7qw`
zrL}7Z7Tclvb|Bpj#o8gsPt!z_<?sIA+W#G|-hXx6)uOAbufBiv_|?l->sG~7WmOHS
zdaP<e)rP9QRcEVkK({)jI;Z;K>Zhtps^6~uqWYKWz?zmdch(H3nNTygW=+k`nv*sE
zsR=XUjBds-<KM<h#+$}|qY}~DoAF)zUig3CXR+n%9d?BM#zK@^l+MZ^<x%B1Wu5Y|
z@{LlZG*lDR9_mQ-Np-QhMXgYOQf-<`>!9_~^0jBRmD&#NE9@)O(cAbLYO~Y`N68m+
z|D5#R9m}8i=JmHHt?Lu-y4vvBA5-=}(EaJopT%|<(PwSh!;4O4Ho0B<tjXC=b}jn2
zQBD49J&$jHw`#+qM)2W>JN+`R@4FqVo+w`5tYY@GMST*Y2i<#c^PW}f=dSzb(!I}~
zk9st6$&ZipDoCH#ZQtwn@89yk<a!;aw(WcM?$r6AAM{+9oi_Hz1;rn?pW1ToQxm?t
z^x}Ije)`#rlJC~FX|ymf`Ik8xQ`%g8C~aehJ9mA4^3d+-Z-08Q$t@XQf3#pv%WeCY
zJ^cLil|vtIF?!vx%U=x+={NGVS6lu1;fd$3e0#CH&{$i#e)HyMyH6R-2M?XuEB^iD
zTx0v5KCRxKSM=093*Py6>--jv{^#V}^6$!*y>oKa{KqHE`fTu;E1xYco%?)###;|J
zsPo>H3yx>DBqWUJ)3WT-bx%B2vFqDAU$S+$waw1ZL1zv=H-6MhEn2K~e!`~xws~gt
zPfhARH{9{v_I<N*#s=)$UKBH;@wfdNZ9QP>b@~!Q)6@)I_t8%U>!%0Izf#cd&L`h&
zVBhoD{ug)T5Bl-3{fYmcn^*Y5Yb(+|{~|MTQKMG3^jvn!)t!eDmJj>6bp7t4v=JxD
zj*WP&$sEVW(-z(I&(8n3>4Ba7zHhoJX4Ku!{Wv?n$?)^aSKS}|WzkEoKC=9&hacbc
zSV6#VkA{Ce`IR%hH+}HY;(^c27&znh2Nvx9s8`DFH%ngpbI_(XFPt7+^3prYvQD%t
zYIiL8gT*TcEnE2NxJA1z?|=7)-o4&CzV+Kqk-s&%ST$>9!JvbS_q+C;?A83Sivt=i
zY#-n3#p9bxzFqL<=|Q~?94+mbv3kYPDT}X$W~^A<qsOFeO_ro@`DM;)&&Eu@e^ux&
z%_>?a%=_WH6`_ll1}}N#>f+GvTVLuh^r$O(-BX{f{?~(dWfaDKy-rI%)BL@;M#h7;
zEqQ28r}CmDOB*E}TGRCOrss||e);I5C*L0P-h!VVK7V0x2X*Efrd<E}@4IiA6UB~C
z%mr$?#J?`-KS#RHdca!0Te+JKOiJsJ*nu@2m@LqDy>I3FE9}~(OM6#zr*XsbTs=mO
znONXz7nc+lADhtHyupu~jL#cCVcdivLs{IIu@gqbJv3%w+|Y@mMh}l2HJphj{HOML
zEN=MZG2<scV&a5x=9@_)#*H5}c1*2@!FV@r#ONVZK;Gq#p1|TpjTwc%xQ%;gEN&)@
zD8S#5NJXZx!-q^5!s15c4IVje$Ri^L=M4uD>j~6{4I4b7VAzQK34_7s=n*Ed!9&K4
z8#39XVcioQsvRT+r$ZhYH4Np)PN0gBBB~iWemsjCHujN6MvRfp@m~q?2Jb2EK(PWV
z+L9)3ENtOZ*4K2>w-_%Y7GRaP;vW`HkrS7xefa*l54~tS6AxB-D?Vc3j&QR8)k~zT
z@-kU`51VLP<*j&&g;spUq~bmfX+4VHc%fK_Ro;qkSQsi_So~Z0ETr%X#ZIheD}G{O
zu53T?Palhai-F!U-70UzYb><lHCFvrd8_>o%JQ8hK`Z`ap%pKp^5p0Fmd`^Pv1rAo
ztoWFPRvZjj#O2%n!;tD--X+)T7K;B{Se7LSmG>4>yw1CPne>Y-wD^_9-27YVv^?=H
zzeAR{a6>aoawY|<UW*=`WbiI;#RDz0;)GUy-}X<F<*oh`|Dh{oE-~xvi?cf3m&^MB
z_s`-(^;_lp?KjI=ILHdr$#TB+zvNTC{7bXEg~j-WkoRTD%}RR}H{SJUH!^FmkbV>0
z`|_=SGhRCJF>A$n5*Z)OPBnA-%G;{n!uL^@Rw`C`E56!KmbdaDi@2<33qM6F@o$yS
zmG$S!@-DYxo8^7^`3lLD#VT*bxe7a){9hpAxU6<t^;&c&JmXz|{yk>S{5wpfujP1O
zR(T6g`;=!g-pkU>^70tCn}k))!gD_5t#xE>rddAR3It0EE;l9f<~IP*a<_kwS+2mE
q-+lOZnZ?|H|G*t(iFc=%H&%I<Pr60U8?Cy%vo5?&{Z=_E@BacMsY9Uv

diff --git a/_b_asic_debug_log.txt b/_b_asic_debug_log.txt
deleted file mode 100644
index 206b80bc..00000000
--- a/_b_asic_debug_log.txt
+++ /dev/null
@@ -1,119738 +0,0 @@
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 2
-Instruction count: 8
-Required stack size: 3
-Delay count: 0
-Result count: 6
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "in1"
- 3: "in2"
- 4: "1"
- 5: "add2"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: push_input inputs[1]       -> 3: "in2"
- 2: addition                   -> 1: "add1"
- 3: forward_value              -> 0: "0"
- 4: push_result results[1]     -> 1: "add1"
- 5: push_result results[3]     -> 3: "in2"
- 6: addition                   -> 5: "add2"
- 7: forward_value              -> 4: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 2
-Instruction count: 8
-Required stack size: 3
-Delay count: 0
-Result count: 6
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "in1"
- 3: "in2"
- 4: "1"
- 5: "add2"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: push_input inputs[1]       -> 3: "in2"
- 2: addition                   -> 1: "add1"
- 3: forward_value              -> 0: "0"
- 4: push_result results[1]     -> 1: "add1"
- 5: push_result results[3]     -> 3: "in2"
- 6: addition                   -> 5: "add2"
- 7: forward_value              -> 4: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 2
-Instruction count: 8
-Required stack size: 3
-Delay count: 0
-Result count: 6
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "in1"
- 3: "in2"
- 4: "1"
- 5: "add2"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: push_input inputs[1]       -> 3: "in2"
- 2: addition                   -> 1: "add1"
- 3: forward_value              -> 0: "0"
- 4: push_result results[1]     -> 1: "add1"
- 5: push_result results[3]     -> 3: "in2"
- 6: addition                   -> 5: "add2"
- 7: forward_value              -> 4: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 2
-Instruction count: 8
-Required stack size: 3
-Delay count: 0
-Result count: 6
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "in1"
- 3: "in2"
- 4: "1"
- 5: "add2"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: push_input inputs[1]       -> 3: "in2"
- 2: addition                   -> 1: "add1"
- 3: forward_value              -> 0: "0"
- 4: push_result results[1]     -> 1: "add1"
- 5: push_result results[3]     -> 3: "in2"
- 6: addition                   -> 5: "add2"
- 7: forward_value              -> 4: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 1
-Output count: 1
-Instruction count: 4
-Required stack size: 2
-Delay count: 1
-Result count: 3
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
- 0: Initial value: 0.0, Result: 1: "t1"
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "t1"
- 2: "in1"
-==============================================
-> Instructions
-==============================================
- 0: push_delay delays[0]       -> 1: "t1"
- 1: forward_value              -> 0: "0"
- 2: push_input inputs[0]       -> 2: "in1"
- 3: update_delay delays[0]
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating update_delay delays[0].
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 2
-Instruction count: 8
-Required stack size: 3
-Delay count: 0
-Result count: 6
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "in1"
- 3: "in2"
- 4: "1"
- 5: "add2"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: push_input inputs[1]       -> 3: "in2"
- 2: addition                   -> 1: "add1"
- 3: forward_value              -> 0: "0"
- 4: push_result results[1]     -> 1: "add1"
- 5: push_result results[3]     -> 3: "in2"
- 6: addition                   -> 5: "add2"
- 7: forward_value              -> 4: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_result results[3].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 1
-Instruction count: 26
-Required stack size: 5
-Delay count: 0
-Result count: 21
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "sfg3"
- 2: "sfg3.add1"
- 3: "sfg3.in1"
- 4: "in1"
- 5: "sfg3.mul1"
- 6: "sfg3.in2"
- 7: "sfg1"
- 8: "sfg1.add1"
- 9: "sfg1.in1"
-10: "sfg1.mul1"
-11: "sfg1.in2"
-12: "sfg1.in3"
-13: "in2"
-14: "sfg3.in3"
-15: "sfg2"
-16: "sfg2.add1"
-17: "sfg2.in1"
-18: "sfg2.mul1"
-19: "sfg2.in2"
-20: "sfg2.in3"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 4: "in1"
- 1: forward_value              -> 3: "sfg3.in1"
- 2: push_result results[4]     -> 4: "in1"
- 3: forward_value              -> 9: "sfg1.in1"
- 4: push_result results[4]     -> 4: "in1"
- 5: forward_value              -> 11: "sfg1.in2"
- 6: push_input inputs[1]       -> 13: "in2"
- 7: forward_value              -> 12: "sfg1.in3"
- 8: multiplication             -> 10: "sfg1.mul1"
- 9: addition                   -> 8: "sfg1.add1"
-10: forward_value              -> 7: "sfg1"
-11: forward_value              -> 6: "sfg3.in2"
-12: push_result results[4]     -> 4: "in1"
-13: forward_value              -> 17: "sfg2.in1"
-14: push_result results[13]    -> 13: "in2"
-15: forward_value              -> 19: "sfg2.in2"
-16: push_result results[7]     -> 7: "sfg1"
-17: forward_value              -> 20: "sfg2.in3"
-18: multiplication             -> 18: "sfg2.mul1"
-19: addition                   -> 16: "sfg2.add1"
-20: forward_value              -> 15: "sfg2"
-21: forward_value              -> 14: "sfg3.in3"
-22: multiplication             -> 5: "sfg3.mul1"
-23: addition                   -> 2: "sfg3.add1"
-24: forward_value              -> 1: "sfg3"
-25: forward_value              -> 0: "0"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[4].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[4].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[4].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[13].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[7].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[4].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[4].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[4].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[13].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[7].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 2
-Output count: 1
-Instruction count: 10
-Required stack size: 4
-Delay count: 1
-Result count: 8
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
- 0: Initial value: 0.0, Result: 1: "t1"
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "t1"
- 2: "mul1"
- 3: "add1"
- 4: "in1"
- 5: "sub1"
- 6: "c1"
- 7: "in2"
-==============================================
-> Instructions
-==============================================
- 0: push_delay delays[0]       -> 1: "t1"
- 1: forward_value              -> 0: "0"
- 2: push_result results[1]     -> 1: "t1"
- 3: push_input inputs[0]       -> 4: "in1"
- 4: addition                   -> 3: "add1"
- 5: push_constant 1.0          -> 6: "c1"
- 6: push_input inputs[1]       -> 7: "in2"
- 7: subtraction                -> 5: "sub1"
- 8: multiplication             -> 2: "mul1"
- 9: update_delay delays[0]
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_input inputs[1].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating multiplication.
-run.cpp:80                              : Evaluating update_delay delays[0].
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 1
-Output count: 1
-Instruction count: 6
-Required stack size: 2
-Delay count: 1
-Result count: 4
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
- 0: Initial value: 0.0, Result: 3: "t1"
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "in1"
- 3: "t1"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: push_delay delays[0]       -> 3: "t1"
- 2: addition                   -> 1: "add1"
- 3: forward_value              -> 0: "0"
- 4: push_result results[1]     -> 1: "add1"
- 5: update_delay delays[0]
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating update_delay delays[0].
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 1
-Output count: 1
-Instruction count: 7
-Required stack size: 3
-Delay count: 1
-Result count: 5
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
- 0: Initial value: 0.0, Result: 1: "t1"
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "t1"
- 2: "add1"
- 3: "in1"
- 4: "cmul1"
-==============================================
-> Instructions
-==============================================
- 0: push_delay delays[0]       -> 1: "t1"
- 1: forward_value              -> 0: "0"
- 2: push_input inputs[0]       -> 3: "in1"
- 3: push_result results[1]     -> 1: "t1"
- 4: constant_multiplication 0.5 -> 4: "cmul1"
- 5: addition                   -> 2: "add1"
- 6: update_delay delays[0]
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating constant_multiplication 0.5.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating constant_multiplication 0.5.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating constant_multiplication 0.5.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating constant_multiplication 0.5.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating update_delay delays[0].
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_delay delays[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating push_result results[1].
-run.cpp:80                              : Evaluating constant_multiplication 0.5.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating update_delay delays[0].
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 1
-Output count: 2
-Instruction count: 6
-Required stack size: 2
-Delay count: 0
-Result count: 5
-Custom operation count: 1
-Custom source count: 2
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "custom1.0"
- 2: "in1"
- 3: "1"
- 4: "custom1.1"
-==============================================
-> Instructions
-==============================================
- 0: push_input inputs[0]       -> 2: "in1"
- 1: custom custom_sources[0]   -> 1: "custom1.0"
- 2: forward_value              -> 0: "0"
- 3: push_result results[2]     -> 2: "in1"
- 4: custom custom_sources[1]   -> 4: "custom1.1"
- 5: forward_value              -> 3: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating custom custom_sources[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating custom custom_sources[1].
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating custom custom_sources[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating custom custom_sources[1].
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating custom custom_sources[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating custom custom_sources[1].
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating custom custom_sources[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating custom custom_sources[1].
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_input inputs[0].
-run.cpp:80                              : Evaluating custom custom_sources[0].
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating custom custom_sources[1].
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 0
-Output count: 1
-Instruction count: 602
-Required stack size: 2
-Delay count: 0
-Result count: 602
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "add1"
- 2: "add2"
- 3: "add3"
- 4: "add4"
- 5: "add5"
- 6: "add6"
- 7: "add7"
- 8: "add8"
- 9: "add9"
-10: "add10"
-11: "add11"
-12: "add12"
-13: "add13"
-14: "add14"
-15: "add15"
-16: "add16"
-17: "add17"
-18: "add18"
-19: "add19"
-20: "add20"
-21: "add21"
-22: "add22"
-23: "add23"
-24: "add24"
-25: "add25"
-26: "add26"
-27: "add27"
-28: "add28"
-29: "add29"
-30: "add30"
-31: "add31"
-32: "add32"
-33: "add33"
-34: "add34"
-35: "add35"
-36: "add36"
-37: "add37"
-38: "add38"
-39: "add39"
-40: "add40"
-41: "add41"
-42: "add42"
-43: "add43"
-44: "add44"
-45: "add45"
-46: "add46"
-47: "add47"
-48: "add48"
-49: "add49"
-50: "add50"
-51: "add51"
-52: "add52"
-53: "add53"
-54: "add54"
-55: "add55"
-56: "add56"
-57: "add57"
-58: "add58"
-59: "add59"
-60: "add60"
-61: "add61"
-62: "add62"
-63: "add63"
-64: "add64"
-65: "add65"
-66: "add66"
-67: "add67"
-68: "add68"
-69: "add69"
-70: "add70"
-71: "add71"
-72: "add72"
-73: "add73"
-74: "add74"
-75: "add75"
-76: "add76"
-77: "add77"
-78: "add78"
-79: "add79"
-80: "add80"
-81: "add81"
-82: "add82"
-83: "add83"
-84: "add84"
-85: "add85"
-86: "add86"
-87: "add87"
-88: "add88"
-89: "add89"
-90: "add90"
-91: "add91"
-92: "add92"
-93: "add93"
-94: "add94"
-95: "add95"
-96: "add96"
-97: "add97"
-98: "add98"
-99: "add99"
-100: "add100"
-101: "add101"
-102: "add102"
-103: "add103"
-104: "add104"
-105: "add105"
-106: "add106"
-107: "add107"
-108: "add108"
-109: "add109"
-110: "add110"
-111: "add111"
-112: "add112"
-113: "add113"
-114: "add114"
-115: "add115"
-116: "add116"
-117: "add117"
-118: "add118"
-119: "add119"
-120: "add120"
-121: "add121"
-122: "add122"
-123: "add123"
-124: "add124"
-125: "add125"
-126: "add126"
-127: "add127"
-128: "add128"
-129: "add129"
-130: "add130"
-131: "add131"
-132: "add132"
-133: "add133"
-134: "add134"
-135: "add135"
-136: "add136"
-137: "add137"
-138: "add138"
-139: "add139"
-140: "add140"
-141: "add141"
-142: "add142"
-143: "add143"
-144: "add144"
-145: "add145"
-146: "add146"
-147: "add147"
-148: "add148"
-149: "add149"
-150: "add150"
-151: "add151"
-152: "add152"
-153: "add153"
-154: "add154"
-155: "add155"
-156: "add156"
-157: "add157"
-158: "add158"
-159: "add159"
-160: "add160"
-161: "add161"
-162: "add162"
-163: "add163"
-164: "add164"
-165: "add165"
-166: "add166"
-167: "add167"
-168: "add168"
-169: "add169"
-170: "add170"
-171: "add171"
-172: "add172"
-173: "add173"
-174: "add174"
-175: "add175"
-176: "add176"
-177: "add177"
-178: "add178"
-179: "add179"
-180: "add180"
-181: "add181"
-182: "add182"
-183: "add183"
-184: "add184"
-185: "add185"
-186: "add186"
-187: "add187"
-188: "add188"
-189: "add189"
-190: "add190"
-191: "add191"
-192: "add192"
-193: "add193"
-194: "add194"
-195: "add195"
-196: "add196"
-197: "add197"
-198: "add198"
-199: "add199"
-200: "add200"
-201: "add201"
-202: "add202"
-203: "add203"
-204: "add204"
-205: "add205"
-206: "add206"
-207: "add207"
-208: "add208"
-209: "add209"
-210: "add210"
-211: "add211"
-212: "add212"
-213: "add213"
-214: "add214"
-215: "add215"
-216: "add216"
-217: "add217"
-218: "add218"
-219: "add219"
-220: "add220"
-221: "add221"
-222: "add222"
-223: "add223"
-224: "add224"
-225: "add225"
-226: "add226"
-227: "add227"
-228: "add228"
-229: "add229"
-230: "add230"
-231: "add231"
-232: "add232"
-233: "add233"
-234: "add234"
-235: "add235"
-236: "add236"
-237: "add237"
-238: "add238"
-239: "add239"
-240: "add240"
-241: "add241"
-242: "add242"
-243: "add243"
-244: "add244"
-245: "add245"
-246: "add246"
-247: "add247"
-248: "add248"
-249: "add249"
-250: "add250"
-251: "add251"
-252: "add252"
-253: "add253"
-254: "add254"
-255: "add255"
-256: "add256"
-257: "add257"
-258: "add258"
-259: "add259"
-260: "add260"
-261: "add261"
-262: "add262"
-263: "add263"
-264: "add264"
-265: "add265"
-266: "add266"
-267: "add267"
-268: "add268"
-269: "add269"
-270: "add270"
-271: "add271"
-272: "add272"
-273: "add273"
-274: "add274"
-275: "add275"
-276: "add276"
-277: "add277"
-278: "add278"
-279: "add279"
-280: "add280"
-281: "add281"
-282: "add282"
-283: "add283"
-284: "add284"
-285: "add285"
-286: "add286"
-287: "add287"
-288: "add288"
-289: "add289"
-290: "add290"
-291: "add291"
-292: "add292"
-293: "add293"
-294: "add294"
-295: "add295"
-296: "add296"
-297: "add297"
-298: "add298"
-299: "add299"
-300: "add300"
-301: "c300"
-302: "c301"
-303: "c299"
-304: "c298"
-305: "c297"
-306: "c296"
-307: "c295"
-308: "c294"
-309: "c293"
-310: "c292"
-311: "c291"
-312: "c290"
-313: "c289"
-314: "c288"
-315: "c287"
-316: "c286"
-317: "c285"
-318: "c284"
-319: "c283"
-320: "c282"
-321: "c281"
-322: "c280"
-323: "c279"
-324: "c278"
-325: "c277"
-326: "c276"
-327: "c275"
-328: "c274"
-329: "c273"
-330: "c272"
-331: "c271"
-332: "c270"
-333: "c269"
-334: "c268"
-335: "c267"
-336: "c266"
-337: "c265"
-338: "c264"
-339: "c263"
-340: "c262"
-341: "c261"
-342: "c260"
-343: "c259"
-344: "c258"
-345: "c257"
-346: "c256"
-347: "c255"
-348: "c254"
-349: "c253"
-350: "c252"
-351: "c251"
-352: "c250"
-353: "c249"
-354: "c248"
-355: "c247"
-356: "c246"
-357: "c245"
-358: "c244"
-359: "c243"
-360: "c242"
-361: "c241"
-362: "c240"
-363: "c239"
-364: "c238"
-365: "c237"
-366: "c236"
-367: "c235"
-368: "c234"
-369: "c233"
-370: "c232"
-371: "c231"
-372: "c230"
-373: "c229"
-374: "c228"
-375: "c227"
-376: "c226"
-377: "c225"
-378: "c224"
-379: "c223"
-380: "c222"
-381: "c221"
-382: "c220"
-383: "c219"
-384: "c218"
-385: "c217"
-386: "c216"
-387: "c215"
-388: "c214"
-389: "c213"
-390: "c212"
-391: "c211"
-392: "c210"
-393: "c209"
-394: "c208"
-395: "c207"
-396: "c206"
-397: "c205"
-398: "c204"
-399: "c203"
-400: "c202"
-401: "c201"
-402: "c200"
-403: "c199"
-404: "c198"
-405: "c197"
-406: "c196"
-407: "c195"
-408: "c194"
-409: "c193"
-410: "c192"
-411: "c191"
-412: "c190"
-413: "c189"
-414: "c188"
-415: "c187"
-416: "c186"
-417: "c185"
-418: "c184"
-419: "c183"
-420: "c182"
-421: "c181"
-422: "c180"
-423: "c179"
-424: "c178"
-425: "c177"
-426: "c176"
-427: "c175"
-428: "c174"
-429: "c173"
-430: "c172"
-431: "c171"
-432: "c170"
-433: "c169"
-434: "c168"
-435: "c167"
-436: "c166"
-437: "c165"
-438: "c164"
-439: "c163"
-440: "c162"
-441: "c161"
-442: "c160"
-443: "c159"
-444: "c158"
-445: "c157"
-446: "c156"
-447: "c155"
-448: "c154"
-449: "c153"
-450: "c152"
-451: "c151"
-452: "c150"
-453: "c149"
-454: "c148"
-455: "c147"
-456: "c146"
-457: "c145"
-458: "c144"
-459: "c143"
-460: "c142"
-461: "c141"
-462: "c140"
-463: "c139"
-464: "c138"
-465: "c137"
-466: "c136"
-467: "c135"
-468: "c134"
-469: "c133"
-470: "c132"
-471: "c131"
-472: "c130"
-473: "c129"
-474: "c128"
-475: "c127"
-476: "c126"
-477: "c125"
-478: "c124"
-479: "c123"
-480: "c122"
-481: "c121"
-482: "c120"
-483: "c119"
-484: "c118"
-485: "c117"
-486: "c116"
-487: "c115"
-488: "c114"
-489: "c113"
-490: "c112"
-491: "c111"
-492: "c110"
-493: "c109"
-494: "c108"
-495: "c107"
-496: "c106"
-497: "c105"
-498: "c104"
-499: "c103"
-500: "c102"
-501: "c101"
-502: "c100"
-503: "c99"
-504: "c98"
-505: "c97"
-506: "c96"
-507: "c95"
-508: "c94"
-509: "c93"
-510: "c92"
-511: "c91"
-512: "c90"
-513: "c89"
-514: "c88"
-515: "c87"
-516: "c86"
-517: "c85"
-518: "c84"
-519: "c83"
-520: "c82"
-521: "c81"
-522: "c80"
-523: "c79"
-524: "c78"
-525: "c77"
-526: "c76"
-527: "c75"
-528: "c74"
-529: "c73"
-530: "c72"
-531: "c71"
-532: "c70"
-533: "c69"
-534: "c68"
-535: "c67"
-536: "c66"
-537: "c65"
-538: "c64"
-539: "c63"
-540: "c62"
-541: "c61"
-542: "c60"
-543: "c59"
-544: "c58"
-545: "c57"
-546: "c56"
-547: "c55"
-548: "c54"
-549: "c53"
-550: "c52"
-551: "c51"
-552: "c50"
-553: "c49"
-554: "c48"
-555: "c47"
-556: "c46"
-557: "c45"
-558: "c44"
-559: "c43"
-560: "c42"
-561: "c41"
-562: "c40"
-563: "c39"
-564: "c38"
-565: "c37"
-566: "c36"
-567: "c35"
-568: "c34"
-569: "c33"
-570: "c32"
-571: "c31"
-572: "c30"
-573: "c29"
-574: "c28"
-575: "c27"
-576: "c26"
-577: "c25"
-578: "c24"
-579: "c23"
-580: "c22"
-581: "c21"
-582: "c20"
-583: "c19"
-584: "c18"
-585: "c17"
-586: "c16"
-587: "c15"
-588: "c14"
-589: "c13"
-590: "c12"
-591: "c11"
-592: "c10"
-593: "c9"
-594: "c8"
-595: "c7"
-596: "c6"
-597: "c5"
-598: "c4"
-599: "c3"
-600: "c2"
-601: "c1"
-==============================================
-> Instructions
-==============================================
- 0: push_constant 1.0          -> 301: "c300"
- 1: push_constant 1.0          -> 302: "c301"
- 2: addition                   -> 300: "add300"
- 3: push_constant 2.0          -> 303: "c299"
- 4: addition                   -> 299: "add299"
- 5: push_constant 2.0          -> 304: "c298"
- 6: addition                   -> 298: "add298"
- 7: push_constant 2.0          -> 305: "c297"
- 8: addition                   -> 297: "add297"
- 9: push_constant 2.0          -> 306: "c296"
-10: addition                   -> 296: "add296"
-11: push_constant 2.0          -> 307: "c295"
-12: addition                   -> 295: "add295"
-13: push_constant 2.0          -> 308: "c294"
-14: addition                   -> 294: "add294"
-15: push_constant 2.0          -> 309: "c293"
-16: addition                   -> 293: "add293"
-17: push_constant 2.0          -> 310: "c292"
-18: addition                   -> 292: "add292"
-19: push_constant 2.0          -> 311: "c291"
-20: addition                   -> 291: "add291"
-21: push_constant 2.0          -> 312: "c290"
-22: addition                   -> 290: "add290"
-23: push_constant 2.0          -> 313: "c289"
-24: addition                   -> 289: "add289"
-25: push_constant 2.0          -> 314: "c288"
-26: addition                   -> 288: "add288"
-27: push_constant 2.0          -> 315: "c287"
-28: addition                   -> 287: "add287"
-29: push_constant 2.0          -> 316: "c286"
-30: addition                   -> 286: "add286"
-31: push_constant 2.0          -> 317: "c285"
-32: addition                   -> 285: "add285"
-33: push_constant 2.0          -> 318: "c284"
-34: addition                   -> 284: "add284"
-35: push_constant 2.0          -> 319: "c283"
-36: addition                   -> 283: "add283"
-37: push_constant 2.0          -> 320: "c282"
-38: addition                   -> 282: "add282"
-39: push_constant 2.0          -> 321: "c281"
-40: addition                   -> 281: "add281"
-41: push_constant 2.0          -> 322: "c280"
-42: addition                   -> 280: "add280"
-43: push_constant 2.0          -> 323: "c279"
-44: addition                   -> 279: "add279"
-45: push_constant 2.0          -> 324: "c278"
-46: addition                   -> 278: "add278"
-47: push_constant 2.0          -> 325: "c277"
-48: addition                   -> 277: "add277"
-49: push_constant 2.0          -> 326: "c276"
-50: addition                   -> 276: "add276"
-51: push_constant 2.0          -> 327: "c275"
-52: addition                   -> 275: "add275"
-53: push_constant 2.0          -> 328: "c274"
-54: addition                   -> 274: "add274"
-55: push_constant 2.0          -> 329: "c273"
-56: addition                   -> 273: "add273"
-57: push_constant 2.0          -> 330: "c272"
-58: addition                   -> 272: "add272"
-59: push_constant 2.0          -> 331: "c271"
-60: addition                   -> 271: "add271"
-61: push_constant 2.0          -> 332: "c270"
-62: addition                   -> 270: "add270"
-63: push_constant 2.0          -> 333: "c269"
-64: addition                   -> 269: "add269"
-65: push_constant 2.0          -> 334: "c268"
-66: addition                   -> 268: "add268"
-67: push_constant 2.0          -> 335: "c267"
-68: addition                   -> 267: "add267"
-69: push_constant 2.0          -> 336: "c266"
-70: addition                   -> 266: "add266"
-71: push_constant 2.0          -> 337: "c265"
-72: addition                   -> 265: "add265"
-73: push_constant 2.0          -> 338: "c264"
-74: addition                   -> 264: "add264"
-75: push_constant 2.0          -> 339: "c263"
-76: addition                   -> 263: "add263"
-77: push_constant 2.0          -> 340: "c262"
-78: addition                   -> 262: "add262"
-79: push_constant 2.0          -> 341: "c261"
-80: addition                   -> 261: "add261"
-81: push_constant 2.0          -> 342: "c260"
-82: addition                   -> 260: "add260"
-83: push_constant 2.0          -> 343: "c259"
-84: addition                   -> 259: "add259"
-85: push_constant 2.0          -> 344: "c258"
-86: addition                   -> 258: "add258"
-87: push_constant 2.0          -> 345: "c257"
-88: addition                   -> 257: "add257"
-89: push_constant 2.0          -> 346: "c256"
-90: addition                   -> 256: "add256"
-91: push_constant 2.0          -> 347: "c255"
-92: addition                   -> 255: "add255"
-93: push_constant 2.0          -> 348: "c254"
-94: addition                   -> 254: "add254"
-95: push_constant 2.0          -> 349: "c253"
-96: addition                   -> 253: "add253"
-97: push_constant 2.0          -> 350: "c252"
-98: addition                   -> 252: "add252"
-99: push_constant 2.0          -> 351: "c251"
-100: addition                   -> 251: "add251"
-101: push_constant 2.0          -> 352: "c250"
-102: addition                   -> 250: "add250"
-103: push_constant 2.0          -> 353: "c249"
-104: addition                   -> 249: "add249"
-105: push_constant 2.0          -> 354: "c248"
-106: addition                   -> 248: "add248"
-107: push_constant 2.0          -> 355: "c247"
-108: addition                   -> 247: "add247"
-109: push_constant 2.0          -> 356: "c246"
-110: addition                   -> 246: "add246"
-111: push_constant 2.0          -> 357: "c245"
-112: addition                   -> 245: "add245"
-113: push_constant 2.0          -> 358: "c244"
-114: addition                   -> 244: "add244"
-115: push_constant 2.0          -> 359: "c243"
-116: addition                   -> 243: "add243"
-117: push_constant 2.0          -> 360: "c242"
-118: addition                   -> 242: "add242"
-119: push_constant 2.0          -> 361: "c241"
-120: addition                   -> 241: "add241"
-121: push_constant 2.0          -> 362: "c240"
-122: addition                   -> 240: "add240"
-123: push_constant 2.0          -> 363: "c239"
-124: addition                   -> 239: "add239"
-125: push_constant 2.0          -> 364: "c238"
-126: addition                   -> 238: "add238"
-127: push_constant 2.0          -> 365: "c237"
-128: addition                   -> 237: "add237"
-129: push_constant 2.0          -> 366: "c236"
-130: addition                   -> 236: "add236"
-131: push_constant 2.0          -> 367: "c235"
-132: addition                   -> 235: "add235"
-133: push_constant 2.0          -> 368: "c234"
-134: addition                   -> 234: "add234"
-135: push_constant 2.0          -> 369: "c233"
-136: addition                   -> 233: "add233"
-137: push_constant 2.0          -> 370: "c232"
-138: addition                   -> 232: "add232"
-139: push_constant 2.0          -> 371: "c231"
-140: addition                   -> 231: "add231"
-141: push_constant 2.0          -> 372: "c230"
-142: addition                   -> 230: "add230"
-143: push_constant 2.0          -> 373: "c229"
-144: addition                   -> 229: "add229"
-145: push_constant 2.0          -> 374: "c228"
-146: addition                   -> 228: "add228"
-147: push_constant 2.0          -> 375: "c227"
-148: addition                   -> 227: "add227"
-149: push_constant 2.0          -> 376: "c226"
-150: addition                   -> 226: "add226"
-151: push_constant 2.0          -> 377: "c225"
-152: addition                   -> 225: "add225"
-153: push_constant 2.0          -> 378: "c224"
-154: addition                   -> 224: "add224"
-155: push_constant 2.0          -> 379: "c223"
-156: addition                   -> 223: "add223"
-157: push_constant 2.0          -> 380: "c222"
-158: addition                   -> 222: "add222"
-159: push_constant 2.0          -> 381: "c221"
-160: addition                   -> 221: "add221"
-161: push_constant 2.0          -> 382: "c220"
-162: addition                   -> 220: "add220"
-163: push_constant 2.0          -> 383: "c219"
-164: addition                   -> 219: "add219"
-165: push_constant 2.0          -> 384: "c218"
-166: addition                   -> 218: "add218"
-167: push_constant 2.0          -> 385: "c217"
-168: addition                   -> 217: "add217"
-169: push_constant 2.0          -> 386: "c216"
-170: addition                   -> 216: "add216"
-171: push_constant 2.0          -> 387: "c215"
-172: addition                   -> 215: "add215"
-173: push_constant 2.0          -> 388: "c214"
-174: addition                   -> 214: "add214"
-175: push_constant 2.0          -> 389: "c213"
-176: addition                   -> 213: "add213"
-177: push_constant 2.0          -> 390: "c212"
-178: addition                   -> 212: "add212"
-179: push_constant 2.0          -> 391: "c211"
-180: addition                   -> 211: "add211"
-181: push_constant 2.0          -> 392: "c210"
-182: addition                   -> 210: "add210"
-183: push_constant 2.0          -> 393: "c209"
-184: addition                   -> 209: "add209"
-185: push_constant 2.0          -> 394: "c208"
-186: addition                   -> 208: "add208"
-187: push_constant 2.0          -> 395: "c207"
-188: addition                   -> 207: "add207"
-189: push_constant 2.0          -> 396: "c206"
-190: addition                   -> 206: "add206"
-191: push_constant 2.0          -> 397: "c205"
-192: addition                   -> 205: "add205"
-193: push_constant 2.0          -> 398: "c204"
-194: addition                   -> 204: "add204"
-195: push_constant 2.0          -> 399: "c203"
-196: addition                   -> 203: "add203"
-197: push_constant 2.0          -> 400: "c202"
-198: addition                   -> 202: "add202"
-199: push_constant 2.0          -> 401: "c201"
-200: addition                   -> 201: "add201"
-201: push_constant 2.0          -> 402: "c200"
-202: addition                   -> 200: "add200"
-203: push_constant 2.0          -> 403: "c199"
-204: addition                   -> 199: "add199"
-205: push_constant 2.0          -> 404: "c198"
-206: addition                   -> 198: "add198"
-207: push_constant 2.0          -> 405: "c197"
-208: addition                   -> 197: "add197"
-209: push_constant 2.0          -> 406: "c196"
-210: addition                   -> 196: "add196"
-211: push_constant 2.0          -> 407: "c195"
-212: addition                   -> 195: "add195"
-213: push_constant 2.0          -> 408: "c194"
-214: addition                   -> 194: "add194"
-215: push_constant 2.0          -> 409: "c193"
-216: addition                   -> 193: "add193"
-217: push_constant 2.0          -> 410: "c192"
-218: addition                   -> 192: "add192"
-219: push_constant 2.0          -> 411: "c191"
-220: addition                   -> 191: "add191"
-221: push_constant 2.0          -> 412: "c190"
-222: addition                   -> 190: "add190"
-223: push_constant 2.0          -> 413: "c189"
-224: addition                   -> 189: "add189"
-225: push_constant 2.0          -> 414: "c188"
-226: addition                   -> 188: "add188"
-227: push_constant 2.0          -> 415: "c187"
-228: addition                   -> 187: "add187"
-229: push_constant 2.0          -> 416: "c186"
-230: addition                   -> 186: "add186"
-231: push_constant 2.0          -> 417: "c185"
-232: addition                   -> 185: "add185"
-233: push_constant 2.0          -> 418: "c184"
-234: addition                   -> 184: "add184"
-235: push_constant 2.0          -> 419: "c183"
-236: addition                   -> 183: "add183"
-237: push_constant 2.0          -> 420: "c182"
-238: addition                   -> 182: "add182"
-239: push_constant 2.0          -> 421: "c181"
-240: addition                   -> 181: "add181"
-241: push_constant 2.0          -> 422: "c180"
-242: addition                   -> 180: "add180"
-243: push_constant 2.0          -> 423: "c179"
-244: addition                   -> 179: "add179"
-245: push_constant 2.0          -> 424: "c178"
-246: addition                   -> 178: "add178"
-247: push_constant 2.0          -> 425: "c177"
-248: addition                   -> 177: "add177"
-249: push_constant 2.0          -> 426: "c176"
-250: addition                   -> 176: "add176"
-251: push_constant 2.0          -> 427: "c175"
-252: addition                   -> 175: "add175"
-253: push_constant 2.0          -> 428: "c174"
-254: addition                   -> 174: "add174"
-255: push_constant 2.0          -> 429: "c173"
-256: addition                   -> 173: "add173"
-257: push_constant 2.0          -> 430: "c172"
-258: addition                   -> 172: "add172"
-259: push_constant 2.0          -> 431: "c171"
-260: addition                   -> 171: "add171"
-261: push_constant 2.0          -> 432: "c170"
-262: addition                   -> 170: "add170"
-263: push_constant 2.0          -> 433: "c169"
-264: addition                   -> 169: "add169"
-265: push_constant 2.0          -> 434: "c168"
-266: addition                   -> 168: "add168"
-267: push_constant 2.0          -> 435: "c167"
-268: addition                   -> 167: "add167"
-269: push_constant 2.0          -> 436: "c166"
-270: addition                   -> 166: "add166"
-271: push_constant 2.0          -> 437: "c165"
-272: addition                   -> 165: "add165"
-273: push_constant 2.0          -> 438: "c164"
-274: addition                   -> 164: "add164"
-275: push_constant 2.0          -> 439: "c163"
-276: addition                   -> 163: "add163"
-277: push_constant 2.0          -> 440: "c162"
-278: addition                   -> 162: "add162"
-279: push_constant 2.0          -> 441: "c161"
-280: addition                   -> 161: "add161"
-281: push_constant 2.0          -> 442: "c160"
-282: addition                   -> 160: "add160"
-283: push_constant 2.0          -> 443: "c159"
-284: addition                   -> 159: "add159"
-285: push_constant 2.0          -> 444: "c158"
-286: addition                   -> 158: "add158"
-287: push_constant 2.0          -> 445: "c157"
-288: addition                   -> 157: "add157"
-289: push_constant 2.0          -> 446: "c156"
-290: addition                   -> 156: "add156"
-291: push_constant 2.0          -> 447: "c155"
-292: addition                   -> 155: "add155"
-293: push_constant 2.0          -> 448: "c154"
-294: addition                   -> 154: "add154"
-295: push_constant 2.0          -> 449: "c153"
-296: addition                   -> 153: "add153"
-297: push_constant 2.0          -> 450: "c152"
-298: addition                   -> 152: "add152"
-299: push_constant 2.0          -> 451: "c151"
-300: addition                   -> 151: "add151"
-301: push_constant 2.0          -> 452: "c150"
-302: addition                   -> 150: "add150"
-303: push_constant 2.0          -> 453: "c149"
-304: addition                   -> 149: "add149"
-305: push_constant 2.0          -> 454: "c148"
-306: addition                   -> 148: "add148"
-307: push_constant 2.0          -> 455: "c147"
-308: addition                   -> 147: "add147"
-309: push_constant 2.0          -> 456: "c146"
-310: addition                   -> 146: "add146"
-311: push_constant 2.0          -> 457: "c145"
-312: addition                   -> 145: "add145"
-313: push_constant 2.0          -> 458: "c144"
-314: addition                   -> 144: "add144"
-315: push_constant 2.0          -> 459: "c143"
-316: addition                   -> 143: "add143"
-317: push_constant 2.0          -> 460: "c142"
-318: addition                   -> 142: "add142"
-319: push_constant 2.0          -> 461: "c141"
-320: addition                   -> 141: "add141"
-321: push_constant 2.0          -> 462: "c140"
-322: addition                   -> 140: "add140"
-323: push_constant 2.0          -> 463: "c139"
-324: addition                   -> 139: "add139"
-325: push_constant 2.0          -> 464: "c138"
-326: addition                   -> 138: "add138"
-327: push_constant 2.0          -> 465: "c137"
-328: addition                   -> 137: "add137"
-329: push_constant 2.0          -> 466: "c136"
-330: addition                   -> 136: "add136"
-331: push_constant 2.0          -> 467: "c135"
-332: addition                   -> 135: "add135"
-333: push_constant 2.0          -> 468: "c134"
-334: addition                   -> 134: "add134"
-335: push_constant 2.0          -> 469: "c133"
-336: addition                   -> 133: "add133"
-337: push_constant 2.0          -> 470: "c132"
-338: addition                   -> 132: "add132"
-339: push_constant 2.0          -> 471: "c131"
-340: addition                   -> 131: "add131"
-341: push_constant 2.0          -> 472: "c130"
-342: addition                   -> 130: "add130"
-343: push_constant 2.0          -> 473: "c129"
-344: addition                   -> 129: "add129"
-345: push_constant 2.0          -> 474: "c128"
-346: addition                   -> 128: "add128"
-347: push_constant 2.0          -> 475: "c127"
-348: addition                   -> 127: "add127"
-349: push_constant 2.0          -> 476: "c126"
-350: addition                   -> 126: "add126"
-351: push_constant 2.0          -> 477: "c125"
-352: addition                   -> 125: "add125"
-353: push_constant 2.0          -> 478: "c124"
-354: addition                   -> 124: "add124"
-355: push_constant 2.0          -> 479: "c123"
-356: addition                   -> 123: "add123"
-357: push_constant 2.0          -> 480: "c122"
-358: addition                   -> 122: "add122"
-359: push_constant 2.0          -> 481: "c121"
-360: addition                   -> 121: "add121"
-361: push_constant 2.0          -> 482: "c120"
-362: addition                   -> 120: "add120"
-363: push_constant 2.0          -> 483: "c119"
-364: addition                   -> 119: "add119"
-365: push_constant 2.0          -> 484: "c118"
-366: addition                   -> 118: "add118"
-367: push_constant 2.0          -> 485: "c117"
-368: addition                   -> 117: "add117"
-369: push_constant 2.0          -> 486: "c116"
-370: addition                   -> 116: "add116"
-371: push_constant 2.0          -> 487: "c115"
-372: addition                   -> 115: "add115"
-373: push_constant 2.0          -> 488: "c114"
-374: addition                   -> 114: "add114"
-375: push_constant 2.0          -> 489: "c113"
-376: addition                   -> 113: "add113"
-377: push_constant 2.0          -> 490: "c112"
-378: addition                   -> 112: "add112"
-379: push_constant 2.0          -> 491: "c111"
-380: addition                   -> 111: "add111"
-381: push_constant 2.0          -> 492: "c110"
-382: addition                   -> 110: "add110"
-383: push_constant 2.0          -> 493: "c109"
-384: addition                   -> 109: "add109"
-385: push_constant 2.0          -> 494: "c108"
-386: addition                   -> 108: "add108"
-387: push_constant 2.0          -> 495: "c107"
-388: addition                   -> 107: "add107"
-389: push_constant 2.0          -> 496: "c106"
-390: addition                   -> 106: "add106"
-391: push_constant 2.0          -> 497: "c105"
-392: addition                   -> 105: "add105"
-393: push_constant 2.0          -> 498: "c104"
-394: addition                   -> 104: "add104"
-395: push_constant 2.0          -> 499: "c103"
-396: addition                   -> 103: "add103"
-397: push_constant 2.0          -> 500: "c102"
-398: addition                   -> 102: "add102"
-399: push_constant 2.0          -> 501: "c101"
-400: addition                   -> 101: "add101"
-401: push_constant 2.0          -> 502: "c100"
-402: addition                   -> 100: "add100"
-403: push_constant 2.0          -> 503: "c99"
-404: addition                   -> 99: "add99"
-405: push_constant 2.0          -> 504: "c98"
-406: addition                   -> 98: "add98"
-407: push_constant 2.0          -> 505: "c97"
-408: addition                   -> 97: "add97"
-409: push_constant 2.0          -> 506: "c96"
-410: addition                   -> 96: "add96"
-411: push_constant 2.0          -> 507: "c95"
-412: addition                   -> 95: "add95"
-413: push_constant 2.0          -> 508: "c94"
-414: addition                   -> 94: "add94"
-415: push_constant 2.0          -> 509: "c93"
-416: addition                   -> 93: "add93"
-417: push_constant 2.0          -> 510: "c92"
-418: addition                   -> 92: "add92"
-419: push_constant 2.0          -> 511: "c91"
-420: addition                   -> 91: "add91"
-421: push_constant 2.0          -> 512: "c90"
-422: addition                   -> 90: "add90"
-423: push_constant 2.0          -> 513: "c89"
-424: addition                   -> 89: "add89"
-425: push_constant 2.0          -> 514: "c88"
-426: addition                   -> 88: "add88"
-427: push_constant 2.0          -> 515: "c87"
-428: addition                   -> 87: "add87"
-429: push_constant 2.0          -> 516: "c86"
-430: addition                   -> 86: "add86"
-431: push_constant 2.0          -> 517: "c85"
-432: addition                   -> 85: "add85"
-433: push_constant 2.0          -> 518: "c84"
-434: addition                   -> 84: "add84"
-435: push_constant 2.0          -> 519: "c83"
-436: addition                   -> 83: "add83"
-437: push_constant 2.0          -> 520: "c82"
-438: addition                   -> 82: "add82"
-439: push_constant 2.0          -> 521: "c81"
-440: addition                   -> 81: "add81"
-441: push_constant 2.0          -> 522: "c80"
-442: addition                   -> 80: "add80"
-443: push_constant 2.0          -> 523: "c79"
-444: addition                   -> 79: "add79"
-445: push_constant 2.0          -> 524: "c78"
-446: addition                   -> 78: "add78"
-447: push_constant 2.0          -> 525: "c77"
-448: addition                   -> 77: "add77"
-449: push_constant 2.0          -> 526: "c76"
-450: addition                   -> 76: "add76"
-451: push_constant 2.0          -> 527: "c75"
-452: addition                   -> 75: "add75"
-453: push_constant 2.0          -> 528: "c74"
-454: addition                   -> 74: "add74"
-455: push_constant 2.0          -> 529: "c73"
-456: addition                   -> 73: "add73"
-457: push_constant 2.0          -> 530: "c72"
-458: addition                   -> 72: "add72"
-459: push_constant 2.0          -> 531: "c71"
-460: addition                   -> 71: "add71"
-461: push_constant 2.0          -> 532: "c70"
-462: addition                   -> 70: "add70"
-463: push_constant 2.0          -> 533: "c69"
-464: addition                   -> 69: "add69"
-465: push_constant 2.0          -> 534: "c68"
-466: addition                   -> 68: "add68"
-467: push_constant 2.0          -> 535: "c67"
-468: addition                   -> 67: "add67"
-469: push_constant 2.0          -> 536: "c66"
-470: addition                   -> 66: "add66"
-471: push_constant 2.0          -> 537: "c65"
-472: addition                   -> 65: "add65"
-473: push_constant 2.0          -> 538: "c64"
-474: addition                   -> 64: "add64"
-475: push_constant 2.0          -> 539: "c63"
-476: addition                   -> 63: "add63"
-477: push_constant 2.0          -> 540: "c62"
-478: addition                   -> 62: "add62"
-479: push_constant 2.0          -> 541: "c61"
-480: addition                   -> 61: "add61"
-481: push_constant 2.0          -> 542: "c60"
-482: addition                   -> 60: "add60"
-483: push_constant 2.0          -> 543: "c59"
-484: addition                   -> 59: "add59"
-485: push_constant 2.0          -> 544: "c58"
-486: addition                   -> 58: "add58"
-487: push_constant 2.0          -> 545: "c57"
-488: addition                   -> 57: "add57"
-489: push_constant 2.0          -> 546: "c56"
-490: addition                   -> 56: "add56"
-491: push_constant 2.0          -> 547: "c55"
-492: addition                   -> 55: "add55"
-493: push_constant 2.0          -> 548: "c54"
-494: addition                   -> 54: "add54"
-495: push_constant 2.0          -> 549: "c53"
-496: addition                   -> 53: "add53"
-497: push_constant 2.0          -> 550: "c52"
-498: addition                   -> 52: "add52"
-499: push_constant 2.0          -> 551: "c51"
-500: addition                   -> 51: "add51"
-501: push_constant 2.0          -> 552: "c50"
-502: addition                   -> 50: "add50"
-503: push_constant 2.0          -> 553: "c49"
-504: addition                   -> 49: "add49"
-505: push_constant 2.0          -> 554: "c48"
-506: addition                   -> 48: "add48"
-507: push_constant 2.0          -> 555: "c47"
-508: addition                   -> 47: "add47"
-509: push_constant 2.0          -> 556: "c46"
-510: addition                   -> 46: "add46"
-511: push_constant 2.0          -> 557: "c45"
-512: addition                   -> 45: "add45"
-513: push_constant 2.0          -> 558: "c44"
-514: addition                   -> 44: "add44"
-515: push_constant 2.0          -> 559: "c43"
-516: addition                   -> 43: "add43"
-517: push_constant 2.0          -> 560: "c42"
-518: addition                   -> 42: "add42"
-519: push_constant 2.0          -> 561: "c41"
-520: addition                   -> 41: "add41"
-521: push_constant 2.0          -> 562: "c40"
-522: addition                   -> 40: "add40"
-523: push_constant 2.0          -> 563: "c39"
-524: addition                   -> 39: "add39"
-525: push_constant 2.0          -> 564: "c38"
-526: addition                   -> 38: "add38"
-527: push_constant 2.0          -> 565: "c37"
-528: addition                   -> 37: "add37"
-529: push_constant 2.0          -> 566: "c36"
-530: addition                   -> 36: "add36"
-531: push_constant 2.0          -> 567: "c35"
-532: addition                   -> 35: "add35"
-533: push_constant 2.0          -> 568: "c34"
-534: addition                   -> 34: "add34"
-535: push_constant 2.0          -> 569: "c33"
-536: addition                   -> 33: "add33"
-537: push_constant 2.0          -> 570: "c32"
-538: addition                   -> 32: "add32"
-539: push_constant 2.0          -> 571: "c31"
-540: addition                   -> 31: "add31"
-541: push_constant 2.0          -> 572: "c30"
-542: addition                   -> 30: "add30"
-543: push_constant 2.0          -> 573: "c29"
-544: addition                   -> 29: "add29"
-545: push_constant 2.0          -> 574: "c28"
-546: addition                   -> 28: "add28"
-547: push_constant 2.0          -> 575: "c27"
-548: addition                   -> 27: "add27"
-549: push_constant 2.0          -> 576: "c26"
-550: addition                   -> 26: "add26"
-551: push_constant 2.0          -> 577: "c25"
-552: addition                   -> 25: "add25"
-553: push_constant 2.0          -> 578: "c24"
-554: addition                   -> 24: "add24"
-555: push_constant 2.0          -> 579: "c23"
-556: addition                   -> 23: "add23"
-557: push_constant 2.0          -> 580: "c22"
-558: addition                   -> 22: "add22"
-559: push_constant 2.0          -> 581: "c21"
-560: addition                   -> 21: "add21"
-561: push_constant 2.0          -> 582: "c20"
-562: addition                   -> 20: "add20"
-563: push_constant 2.0          -> 583: "c19"
-564: addition                   -> 19: "add19"
-565: push_constant 2.0          -> 584: "c18"
-566: addition                   -> 18: "add18"
-567: push_constant 2.0          -> 585: "c17"
-568: addition                   -> 17: "add17"
-569: push_constant 2.0          -> 586: "c16"
-570: addition                   -> 16: "add16"
-571: push_constant 2.0          -> 587: "c15"
-572: addition                   -> 15: "add15"
-573: push_constant 2.0          -> 588: "c14"
-574: addition                   -> 14: "add14"
-575: push_constant 2.0          -> 589: "c13"
-576: addition                   -> 13: "add13"
-577: push_constant 2.0          -> 590: "c12"
-578: addition                   -> 12: "add12"
-579: push_constant 2.0          -> 591: "c11"
-580: addition                   -> 11: "add11"
-581: push_constant 2.0          -> 592: "c10"
-582: addition                   -> 10: "add10"
-583: push_constant 2.0          -> 593: "c9"
-584: addition                   -> 9: "add9"
-585: push_constant 2.0          -> 594: "c8"
-586: addition                   -> 8: "add8"
-587: push_constant 2.0          -> 595: "c7"
-588: addition                   -> 7: "add7"
-589: push_constant 2.0          -> 596: "c6"
-590: addition                   -> 6: "add6"
-591: push_constant 2.0          -> 597: "c5"
-592: addition                   -> 5: "add5"
-593: push_constant 2.0          -> 598: "c4"
-594: addition                   -> 4: "add4"
-595: push_constant 2.0          -> 599: "c3"
-596: addition                   -> 3: "add3"
-597: push_constant 2.0          -> 600: "c2"
-598: addition                   -> 2: "add2"
-599: push_constant 2.0          -> 601: "c1"
-600: addition                   -> 1: "add1"
-601: forward_value              -> 0: "0"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 0
-Output count: 1
-Instruction count: 602
-Required stack size: 2
-Delay count: 0
-Result count: 602
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "sub1"
- 2: "sub2"
- 3: "sub3"
- 4: "sub4"
- 5: "sub5"
- 6: "sub6"
- 7: "sub7"
- 8: "sub8"
- 9: "sub9"
-10: "sub10"
-11: "sub11"
-12: "sub12"
-13: "sub13"
-14: "sub14"
-15: "sub15"
-16: "sub16"
-17: "sub17"
-18: "sub18"
-19: "sub19"
-20: "sub20"
-21: "sub21"
-22: "sub22"
-23: "sub23"
-24: "sub24"
-25: "sub25"
-26: "sub26"
-27: "sub27"
-28: "sub28"
-29: "sub29"
-30: "sub30"
-31: "sub31"
-32: "sub32"
-33: "sub33"
-34: "sub34"
-35: "sub35"
-36: "sub36"
-37: "sub37"
-38: "sub38"
-39: "sub39"
-40: "sub40"
-41: "sub41"
-42: "sub42"
-43: "sub43"
-44: "sub44"
-45: "sub45"
-46: "sub46"
-47: "sub47"
-48: "sub48"
-49: "sub49"
-50: "sub50"
-51: "sub51"
-52: "sub52"
-53: "sub53"
-54: "sub54"
-55: "sub55"
-56: "sub56"
-57: "sub57"
-58: "sub58"
-59: "sub59"
-60: "sub60"
-61: "sub61"
-62: "sub62"
-63: "sub63"
-64: "sub64"
-65: "sub65"
-66: "sub66"
-67: "sub67"
-68: "sub68"
-69: "sub69"
-70: "sub70"
-71: "sub71"
-72: "sub72"
-73: "sub73"
-74: "sub74"
-75: "sub75"
-76: "sub76"
-77: "sub77"
-78: "sub78"
-79: "sub79"
-80: "sub80"
-81: "sub81"
-82: "sub82"
-83: "sub83"
-84: "sub84"
-85: "sub85"
-86: "sub86"
-87: "sub87"
-88: "sub88"
-89: "sub89"
-90: "sub90"
-91: "sub91"
-92: "sub92"
-93: "sub93"
-94: "sub94"
-95: "sub95"
-96: "sub96"
-97: "sub97"
-98: "sub98"
-99: "sub99"
-100: "sub100"
-101: "sub101"
-102: "sub102"
-103: "sub103"
-104: "sub104"
-105: "sub105"
-106: "sub106"
-107: "sub107"
-108: "sub108"
-109: "sub109"
-110: "sub110"
-111: "sub111"
-112: "sub112"
-113: "sub113"
-114: "sub114"
-115: "sub115"
-116: "sub116"
-117: "sub117"
-118: "sub118"
-119: "sub119"
-120: "sub120"
-121: "sub121"
-122: "sub122"
-123: "sub123"
-124: "sub124"
-125: "sub125"
-126: "sub126"
-127: "sub127"
-128: "sub128"
-129: "sub129"
-130: "sub130"
-131: "sub131"
-132: "sub132"
-133: "sub133"
-134: "sub134"
-135: "sub135"
-136: "sub136"
-137: "sub137"
-138: "sub138"
-139: "sub139"
-140: "sub140"
-141: "sub141"
-142: "sub142"
-143: "sub143"
-144: "sub144"
-145: "sub145"
-146: "sub146"
-147: "sub147"
-148: "sub148"
-149: "sub149"
-150: "sub150"
-151: "sub151"
-152: "sub152"
-153: "sub153"
-154: "sub154"
-155: "sub155"
-156: "sub156"
-157: "sub157"
-158: "sub158"
-159: "sub159"
-160: "sub160"
-161: "sub161"
-162: "sub162"
-163: "sub163"
-164: "sub164"
-165: "sub165"
-166: "sub166"
-167: "sub167"
-168: "sub168"
-169: "sub169"
-170: "sub170"
-171: "sub171"
-172: "sub172"
-173: "sub173"
-174: "sub174"
-175: "sub175"
-176: "sub176"
-177: "sub177"
-178: "sub178"
-179: "sub179"
-180: "sub180"
-181: "sub181"
-182: "sub182"
-183: "sub183"
-184: "sub184"
-185: "sub185"
-186: "sub186"
-187: "sub187"
-188: "sub188"
-189: "sub189"
-190: "sub190"
-191: "sub191"
-192: "sub192"
-193: "sub193"
-194: "sub194"
-195: "sub195"
-196: "sub196"
-197: "sub197"
-198: "sub198"
-199: "sub199"
-200: "sub200"
-201: "sub201"
-202: "sub202"
-203: "sub203"
-204: "sub204"
-205: "sub205"
-206: "sub206"
-207: "sub207"
-208: "sub208"
-209: "sub209"
-210: "sub210"
-211: "sub211"
-212: "sub212"
-213: "sub213"
-214: "sub214"
-215: "sub215"
-216: "sub216"
-217: "sub217"
-218: "sub218"
-219: "sub219"
-220: "sub220"
-221: "sub221"
-222: "sub222"
-223: "sub223"
-224: "sub224"
-225: "sub225"
-226: "sub226"
-227: "sub227"
-228: "sub228"
-229: "sub229"
-230: "sub230"
-231: "sub231"
-232: "sub232"
-233: "sub233"
-234: "sub234"
-235: "sub235"
-236: "sub236"
-237: "sub237"
-238: "sub238"
-239: "sub239"
-240: "sub240"
-241: "sub241"
-242: "sub242"
-243: "sub243"
-244: "sub244"
-245: "sub245"
-246: "sub246"
-247: "sub247"
-248: "sub248"
-249: "sub249"
-250: "sub250"
-251: "sub251"
-252: "sub252"
-253: "sub253"
-254: "sub254"
-255: "sub255"
-256: "sub256"
-257: "sub257"
-258: "sub258"
-259: "sub259"
-260: "sub260"
-261: "sub261"
-262: "sub262"
-263: "sub263"
-264: "sub264"
-265: "sub265"
-266: "sub266"
-267: "sub267"
-268: "sub268"
-269: "sub269"
-270: "sub270"
-271: "sub271"
-272: "sub272"
-273: "sub273"
-274: "sub274"
-275: "sub275"
-276: "sub276"
-277: "sub277"
-278: "sub278"
-279: "sub279"
-280: "sub280"
-281: "sub281"
-282: "sub282"
-283: "sub283"
-284: "sub284"
-285: "sub285"
-286: "sub286"
-287: "sub287"
-288: "sub288"
-289: "sub289"
-290: "sub290"
-291: "sub291"
-292: "sub292"
-293: "sub293"
-294: "sub294"
-295: "sub295"
-296: "sub296"
-297: "sub297"
-298: "sub298"
-299: "sub299"
-300: "sub300"
-301: "c300"
-302: "c301"
-303: "c299"
-304: "c298"
-305: "c297"
-306: "c296"
-307: "c295"
-308: "c294"
-309: "c293"
-310: "c292"
-311: "c291"
-312: "c290"
-313: "c289"
-314: "c288"
-315: "c287"
-316: "c286"
-317: "c285"
-318: "c284"
-319: "c283"
-320: "c282"
-321: "c281"
-322: "c280"
-323: "c279"
-324: "c278"
-325: "c277"
-326: "c276"
-327: "c275"
-328: "c274"
-329: "c273"
-330: "c272"
-331: "c271"
-332: "c270"
-333: "c269"
-334: "c268"
-335: "c267"
-336: "c266"
-337: "c265"
-338: "c264"
-339: "c263"
-340: "c262"
-341: "c261"
-342: "c260"
-343: "c259"
-344: "c258"
-345: "c257"
-346: "c256"
-347: "c255"
-348: "c254"
-349: "c253"
-350: "c252"
-351: "c251"
-352: "c250"
-353: "c249"
-354: "c248"
-355: "c247"
-356: "c246"
-357: "c245"
-358: "c244"
-359: "c243"
-360: "c242"
-361: "c241"
-362: "c240"
-363: "c239"
-364: "c238"
-365: "c237"
-366: "c236"
-367: "c235"
-368: "c234"
-369: "c233"
-370: "c232"
-371: "c231"
-372: "c230"
-373: "c229"
-374: "c228"
-375: "c227"
-376: "c226"
-377: "c225"
-378: "c224"
-379: "c223"
-380: "c222"
-381: "c221"
-382: "c220"
-383: "c219"
-384: "c218"
-385: "c217"
-386: "c216"
-387: "c215"
-388: "c214"
-389: "c213"
-390: "c212"
-391: "c211"
-392: "c210"
-393: "c209"
-394: "c208"
-395: "c207"
-396: "c206"
-397: "c205"
-398: "c204"
-399: "c203"
-400: "c202"
-401: "c201"
-402: "c200"
-403: "c199"
-404: "c198"
-405: "c197"
-406: "c196"
-407: "c195"
-408: "c194"
-409: "c193"
-410: "c192"
-411: "c191"
-412: "c190"
-413: "c189"
-414: "c188"
-415: "c187"
-416: "c186"
-417: "c185"
-418: "c184"
-419: "c183"
-420: "c182"
-421: "c181"
-422: "c180"
-423: "c179"
-424: "c178"
-425: "c177"
-426: "c176"
-427: "c175"
-428: "c174"
-429: "c173"
-430: "c172"
-431: "c171"
-432: "c170"
-433: "c169"
-434: "c168"
-435: "c167"
-436: "c166"
-437: "c165"
-438: "c164"
-439: "c163"
-440: "c162"
-441: "c161"
-442: "c160"
-443: "c159"
-444: "c158"
-445: "c157"
-446: "c156"
-447: "c155"
-448: "c154"
-449: "c153"
-450: "c152"
-451: "c151"
-452: "c150"
-453: "c149"
-454: "c148"
-455: "c147"
-456: "c146"
-457: "c145"
-458: "c144"
-459: "c143"
-460: "c142"
-461: "c141"
-462: "c140"
-463: "c139"
-464: "c138"
-465: "c137"
-466: "c136"
-467: "c135"
-468: "c134"
-469: "c133"
-470: "c132"
-471: "c131"
-472: "c130"
-473: "c129"
-474: "c128"
-475: "c127"
-476: "c126"
-477: "c125"
-478: "c124"
-479: "c123"
-480: "c122"
-481: "c121"
-482: "c120"
-483: "c119"
-484: "c118"
-485: "c117"
-486: "c116"
-487: "c115"
-488: "c114"
-489: "c113"
-490: "c112"
-491: "c111"
-492: "c110"
-493: "c109"
-494: "c108"
-495: "c107"
-496: "c106"
-497: "c105"
-498: "c104"
-499: "c103"
-500: "c102"
-501: "c101"
-502: "c100"
-503: "c99"
-504: "c98"
-505: "c97"
-506: "c96"
-507: "c95"
-508: "c94"
-509: "c93"
-510: "c92"
-511: "c91"
-512: "c90"
-513: "c89"
-514: "c88"
-515: "c87"
-516: "c86"
-517: "c85"
-518: "c84"
-519: "c83"
-520: "c82"
-521: "c81"
-522: "c80"
-523: "c79"
-524: "c78"
-525: "c77"
-526: "c76"
-527: "c75"
-528: "c74"
-529: "c73"
-530: "c72"
-531: "c71"
-532: "c70"
-533: "c69"
-534: "c68"
-535: "c67"
-536: "c66"
-537: "c65"
-538: "c64"
-539: "c63"
-540: "c62"
-541: "c61"
-542: "c60"
-543: "c59"
-544: "c58"
-545: "c57"
-546: "c56"
-547: "c55"
-548: "c54"
-549: "c53"
-550: "c52"
-551: "c51"
-552: "c50"
-553: "c49"
-554: "c48"
-555: "c47"
-556: "c46"
-557: "c45"
-558: "c44"
-559: "c43"
-560: "c42"
-561: "c41"
-562: "c40"
-563: "c39"
-564: "c38"
-565: "c37"
-566: "c36"
-567: "c35"
-568: "c34"
-569: "c33"
-570: "c32"
-571: "c31"
-572: "c30"
-573: "c29"
-574: "c28"
-575: "c27"
-576: "c26"
-577: "c25"
-578: "c24"
-579: "c23"
-580: "c22"
-581: "c21"
-582: "c20"
-583: "c19"
-584: "c18"
-585: "c17"
-586: "c16"
-587: "c15"
-588: "c14"
-589: "c13"
-590: "c12"
-591: "c11"
-592: "c10"
-593: "c9"
-594: "c8"
-595: "c7"
-596: "c6"
-597: "c5"
-598: "c4"
-599: "c3"
-600: "c2"
-601: "c1"
-==============================================
-> Instructions
-==============================================
- 0: push_constant 0.0          -> 301: "c300"
- 1: push_constant 2.0          -> 302: "c301"
- 2: subtraction                -> 300: "sub300"
- 3: push_constant 2.0          -> 303: "c299"
- 4: subtraction                -> 299: "sub299"
- 5: push_constant 2.0          -> 304: "c298"
- 6: subtraction                -> 298: "sub298"
- 7: push_constant 2.0          -> 305: "c297"
- 8: subtraction                -> 297: "sub297"
- 9: push_constant 2.0          -> 306: "c296"
-10: subtraction                -> 296: "sub296"
-11: push_constant 2.0          -> 307: "c295"
-12: subtraction                -> 295: "sub295"
-13: push_constant 2.0          -> 308: "c294"
-14: subtraction                -> 294: "sub294"
-15: push_constant 2.0          -> 309: "c293"
-16: subtraction                -> 293: "sub293"
-17: push_constant 2.0          -> 310: "c292"
-18: subtraction                -> 292: "sub292"
-19: push_constant 2.0          -> 311: "c291"
-20: subtraction                -> 291: "sub291"
-21: push_constant 2.0          -> 312: "c290"
-22: subtraction                -> 290: "sub290"
-23: push_constant 2.0          -> 313: "c289"
-24: subtraction                -> 289: "sub289"
-25: push_constant 2.0          -> 314: "c288"
-26: subtraction                -> 288: "sub288"
-27: push_constant 2.0          -> 315: "c287"
-28: subtraction                -> 287: "sub287"
-29: push_constant 2.0          -> 316: "c286"
-30: subtraction                -> 286: "sub286"
-31: push_constant 2.0          -> 317: "c285"
-32: subtraction                -> 285: "sub285"
-33: push_constant 2.0          -> 318: "c284"
-34: subtraction                -> 284: "sub284"
-35: push_constant 2.0          -> 319: "c283"
-36: subtraction                -> 283: "sub283"
-37: push_constant 2.0          -> 320: "c282"
-38: subtraction                -> 282: "sub282"
-39: push_constant 2.0          -> 321: "c281"
-40: subtraction                -> 281: "sub281"
-41: push_constant 2.0          -> 322: "c280"
-42: subtraction                -> 280: "sub280"
-43: push_constant 2.0          -> 323: "c279"
-44: subtraction                -> 279: "sub279"
-45: push_constant 2.0          -> 324: "c278"
-46: subtraction                -> 278: "sub278"
-47: push_constant 2.0          -> 325: "c277"
-48: subtraction                -> 277: "sub277"
-49: push_constant 2.0          -> 326: "c276"
-50: subtraction                -> 276: "sub276"
-51: push_constant 2.0          -> 327: "c275"
-52: subtraction                -> 275: "sub275"
-53: push_constant 2.0          -> 328: "c274"
-54: subtraction                -> 274: "sub274"
-55: push_constant 2.0          -> 329: "c273"
-56: subtraction                -> 273: "sub273"
-57: push_constant 2.0          -> 330: "c272"
-58: subtraction                -> 272: "sub272"
-59: push_constant 2.0          -> 331: "c271"
-60: subtraction                -> 271: "sub271"
-61: push_constant 2.0          -> 332: "c270"
-62: subtraction                -> 270: "sub270"
-63: push_constant 2.0          -> 333: "c269"
-64: subtraction                -> 269: "sub269"
-65: push_constant 2.0          -> 334: "c268"
-66: subtraction                -> 268: "sub268"
-67: push_constant 2.0          -> 335: "c267"
-68: subtraction                -> 267: "sub267"
-69: push_constant 2.0          -> 336: "c266"
-70: subtraction                -> 266: "sub266"
-71: push_constant 2.0          -> 337: "c265"
-72: subtraction                -> 265: "sub265"
-73: push_constant 2.0          -> 338: "c264"
-74: subtraction                -> 264: "sub264"
-75: push_constant 2.0          -> 339: "c263"
-76: subtraction                -> 263: "sub263"
-77: push_constant 2.0          -> 340: "c262"
-78: subtraction                -> 262: "sub262"
-79: push_constant 2.0          -> 341: "c261"
-80: subtraction                -> 261: "sub261"
-81: push_constant 2.0          -> 342: "c260"
-82: subtraction                -> 260: "sub260"
-83: push_constant 2.0          -> 343: "c259"
-84: subtraction                -> 259: "sub259"
-85: push_constant 2.0          -> 344: "c258"
-86: subtraction                -> 258: "sub258"
-87: push_constant 2.0          -> 345: "c257"
-88: subtraction                -> 257: "sub257"
-89: push_constant 2.0          -> 346: "c256"
-90: subtraction                -> 256: "sub256"
-91: push_constant 2.0          -> 347: "c255"
-92: subtraction                -> 255: "sub255"
-93: push_constant 2.0          -> 348: "c254"
-94: subtraction                -> 254: "sub254"
-95: push_constant 2.0          -> 349: "c253"
-96: subtraction                -> 253: "sub253"
-97: push_constant 2.0          -> 350: "c252"
-98: subtraction                -> 252: "sub252"
-99: push_constant 2.0          -> 351: "c251"
-100: subtraction                -> 251: "sub251"
-101: push_constant 2.0          -> 352: "c250"
-102: subtraction                -> 250: "sub250"
-103: push_constant 2.0          -> 353: "c249"
-104: subtraction                -> 249: "sub249"
-105: push_constant 2.0          -> 354: "c248"
-106: subtraction                -> 248: "sub248"
-107: push_constant 2.0          -> 355: "c247"
-108: subtraction                -> 247: "sub247"
-109: push_constant 2.0          -> 356: "c246"
-110: subtraction                -> 246: "sub246"
-111: push_constant 2.0          -> 357: "c245"
-112: subtraction                -> 245: "sub245"
-113: push_constant 2.0          -> 358: "c244"
-114: subtraction                -> 244: "sub244"
-115: push_constant 2.0          -> 359: "c243"
-116: subtraction                -> 243: "sub243"
-117: push_constant 2.0          -> 360: "c242"
-118: subtraction                -> 242: "sub242"
-119: push_constant 2.0          -> 361: "c241"
-120: subtraction                -> 241: "sub241"
-121: push_constant 2.0          -> 362: "c240"
-122: subtraction                -> 240: "sub240"
-123: push_constant 2.0          -> 363: "c239"
-124: subtraction                -> 239: "sub239"
-125: push_constant 2.0          -> 364: "c238"
-126: subtraction                -> 238: "sub238"
-127: push_constant 2.0          -> 365: "c237"
-128: subtraction                -> 237: "sub237"
-129: push_constant 2.0          -> 366: "c236"
-130: subtraction                -> 236: "sub236"
-131: push_constant 2.0          -> 367: "c235"
-132: subtraction                -> 235: "sub235"
-133: push_constant 2.0          -> 368: "c234"
-134: subtraction                -> 234: "sub234"
-135: push_constant 2.0          -> 369: "c233"
-136: subtraction                -> 233: "sub233"
-137: push_constant 2.0          -> 370: "c232"
-138: subtraction                -> 232: "sub232"
-139: push_constant 2.0          -> 371: "c231"
-140: subtraction                -> 231: "sub231"
-141: push_constant 2.0          -> 372: "c230"
-142: subtraction                -> 230: "sub230"
-143: push_constant 2.0          -> 373: "c229"
-144: subtraction                -> 229: "sub229"
-145: push_constant 2.0          -> 374: "c228"
-146: subtraction                -> 228: "sub228"
-147: push_constant 2.0          -> 375: "c227"
-148: subtraction                -> 227: "sub227"
-149: push_constant 2.0          -> 376: "c226"
-150: subtraction                -> 226: "sub226"
-151: push_constant 2.0          -> 377: "c225"
-152: subtraction                -> 225: "sub225"
-153: push_constant 2.0          -> 378: "c224"
-154: subtraction                -> 224: "sub224"
-155: push_constant 2.0          -> 379: "c223"
-156: subtraction                -> 223: "sub223"
-157: push_constant 2.0          -> 380: "c222"
-158: subtraction                -> 222: "sub222"
-159: push_constant 2.0          -> 381: "c221"
-160: subtraction                -> 221: "sub221"
-161: push_constant 2.0          -> 382: "c220"
-162: subtraction                -> 220: "sub220"
-163: push_constant 2.0          -> 383: "c219"
-164: subtraction                -> 219: "sub219"
-165: push_constant 2.0          -> 384: "c218"
-166: subtraction                -> 218: "sub218"
-167: push_constant 2.0          -> 385: "c217"
-168: subtraction                -> 217: "sub217"
-169: push_constant 2.0          -> 386: "c216"
-170: subtraction                -> 216: "sub216"
-171: push_constant 2.0          -> 387: "c215"
-172: subtraction                -> 215: "sub215"
-173: push_constant 2.0          -> 388: "c214"
-174: subtraction                -> 214: "sub214"
-175: push_constant 2.0          -> 389: "c213"
-176: subtraction                -> 213: "sub213"
-177: push_constant 2.0          -> 390: "c212"
-178: subtraction                -> 212: "sub212"
-179: push_constant 2.0          -> 391: "c211"
-180: subtraction                -> 211: "sub211"
-181: push_constant 2.0          -> 392: "c210"
-182: subtraction                -> 210: "sub210"
-183: push_constant 2.0          -> 393: "c209"
-184: subtraction                -> 209: "sub209"
-185: push_constant 2.0          -> 394: "c208"
-186: subtraction                -> 208: "sub208"
-187: push_constant 2.0          -> 395: "c207"
-188: subtraction                -> 207: "sub207"
-189: push_constant 2.0          -> 396: "c206"
-190: subtraction                -> 206: "sub206"
-191: push_constant 2.0          -> 397: "c205"
-192: subtraction                -> 205: "sub205"
-193: push_constant 2.0          -> 398: "c204"
-194: subtraction                -> 204: "sub204"
-195: push_constant 2.0          -> 399: "c203"
-196: subtraction                -> 203: "sub203"
-197: push_constant 2.0          -> 400: "c202"
-198: subtraction                -> 202: "sub202"
-199: push_constant 2.0          -> 401: "c201"
-200: subtraction                -> 201: "sub201"
-201: push_constant 2.0          -> 402: "c200"
-202: subtraction                -> 200: "sub200"
-203: push_constant 2.0          -> 403: "c199"
-204: subtraction                -> 199: "sub199"
-205: push_constant 2.0          -> 404: "c198"
-206: subtraction                -> 198: "sub198"
-207: push_constant 2.0          -> 405: "c197"
-208: subtraction                -> 197: "sub197"
-209: push_constant 2.0          -> 406: "c196"
-210: subtraction                -> 196: "sub196"
-211: push_constant 2.0          -> 407: "c195"
-212: subtraction                -> 195: "sub195"
-213: push_constant 2.0          -> 408: "c194"
-214: subtraction                -> 194: "sub194"
-215: push_constant 2.0          -> 409: "c193"
-216: subtraction                -> 193: "sub193"
-217: push_constant 2.0          -> 410: "c192"
-218: subtraction                -> 192: "sub192"
-219: push_constant 2.0          -> 411: "c191"
-220: subtraction                -> 191: "sub191"
-221: push_constant 2.0          -> 412: "c190"
-222: subtraction                -> 190: "sub190"
-223: push_constant 2.0          -> 413: "c189"
-224: subtraction                -> 189: "sub189"
-225: push_constant 2.0          -> 414: "c188"
-226: subtraction                -> 188: "sub188"
-227: push_constant 2.0          -> 415: "c187"
-228: subtraction                -> 187: "sub187"
-229: push_constant 2.0          -> 416: "c186"
-230: subtraction                -> 186: "sub186"
-231: push_constant 2.0          -> 417: "c185"
-232: subtraction                -> 185: "sub185"
-233: push_constant 2.0          -> 418: "c184"
-234: subtraction                -> 184: "sub184"
-235: push_constant 2.0          -> 419: "c183"
-236: subtraction                -> 183: "sub183"
-237: push_constant 2.0          -> 420: "c182"
-238: subtraction                -> 182: "sub182"
-239: push_constant 2.0          -> 421: "c181"
-240: subtraction                -> 181: "sub181"
-241: push_constant 2.0          -> 422: "c180"
-242: subtraction                -> 180: "sub180"
-243: push_constant 2.0          -> 423: "c179"
-244: subtraction                -> 179: "sub179"
-245: push_constant 2.0          -> 424: "c178"
-246: subtraction                -> 178: "sub178"
-247: push_constant 2.0          -> 425: "c177"
-248: subtraction                -> 177: "sub177"
-249: push_constant 2.0          -> 426: "c176"
-250: subtraction                -> 176: "sub176"
-251: push_constant 2.0          -> 427: "c175"
-252: subtraction                -> 175: "sub175"
-253: push_constant 2.0          -> 428: "c174"
-254: subtraction                -> 174: "sub174"
-255: push_constant 2.0          -> 429: "c173"
-256: subtraction                -> 173: "sub173"
-257: push_constant 2.0          -> 430: "c172"
-258: subtraction                -> 172: "sub172"
-259: push_constant 2.0          -> 431: "c171"
-260: subtraction                -> 171: "sub171"
-261: push_constant 2.0          -> 432: "c170"
-262: subtraction                -> 170: "sub170"
-263: push_constant 2.0          -> 433: "c169"
-264: subtraction                -> 169: "sub169"
-265: push_constant 2.0          -> 434: "c168"
-266: subtraction                -> 168: "sub168"
-267: push_constant 2.0          -> 435: "c167"
-268: subtraction                -> 167: "sub167"
-269: push_constant 2.0          -> 436: "c166"
-270: subtraction                -> 166: "sub166"
-271: push_constant 2.0          -> 437: "c165"
-272: subtraction                -> 165: "sub165"
-273: push_constant 2.0          -> 438: "c164"
-274: subtraction                -> 164: "sub164"
-275: push_constant 2.0          -> 439: "c163"
-276: subtraction                -> 163: "sub163"
-277: push_constant 2.0          -> 440: "c162"
-278: subtraction                -> 162: "sub162"
-279: push_constant 2.0          -> 441: "c161"
-280: subtraction                -> 161: "sub161"
-281: push_constant 2.0          -> 442: "c160"
-282: subtraction                -> 160: "sub160"
-283: push_constant 2.0          -> 443: "c159"
-284: subtraction                -> 159: "sub159"
-285: push_constant 2.0          -> 444: "c158"
-286: subtraction                -> 158: "sub158"
-287: push_constant 2.0          -> 445: "c157"
-288: subtraction                -> 157: "sub157"
-289: push_constant 2.0          -> 446: "c156"
-290: subtraction                -> 156: "sub156"
-291: push_constant 2.0          -> 447: "c155"
-292: subtraction                -> 155: "sub155"
-293: push_constant 2.0          -> 448: "c154"
-294: subtraction                -> 154: "sub154"
-295: push_constant 2.0          -> 449: "c153"
-296: subtraction                -> 153: "sub153"
-297: push_constant 2.0          -> 450: "c152"
-298: subtraction                -> 152: "sub152"
-299: push_constant 2.0          -> 451: "c151"
-300: subtraction                -> 151: "sub151"
-301: push_constant 2.0          -> 452: "c150"
-302: subtraction                -> 150: "sub150"
-303: push_constant 2.0          -> 453: "c149"
-304: subtraction                -> 149: "sub149"
-305: push_constant 2.0          -> 454: "c148"
-306: subtraction                -> 148: "sub148"
-307: push_constant 2.0          -> 455: "c147"
-308: subtraction                -> 147: "sub147"
-309: push_constant 2.0          -> 456: "c146"
-310: subtraction                -> 146: "sub146"
-311: push_constant 2.0          -> 457: "c145"
-312: subtraction                -> 145: "sub145"
-313: push_constant 2.0          -> 458: "c144"
-314: subtraction                -> 144: "sub144"
-315: push_constant 2.0          -> 459: "c143"
-316: subtraction                -> 143: "sub143"
-317: push_constant 2.0          -> 460: "c142"
-318: subtraction                -> 142: "sub142"
-319: push_constant 2.0          -> 461: "c141"
-320: subtraction                -> 141: "sub141"
-321: push_constant 2.0          -> 462: "c140"
-322: subtraction                -> 140: "sub140"
-323: push_constant 2.0          -> 463: "c139"
-324: subtraction                -> 139: "sub139"
-325: push_constant 2.0          -> 464: "c138"
-326: subtraction                -> 138: "sub138"
-327: push_constant 2.0          -> 465: "c137"
-328: subtraction                -> 137: "sub137"
-329: push_constant 2.0          -> 466: "c136"
-330: subtraction                -> 136: "sub136"
-331: push_constant 2.0          -> 467: "c135"
-332: subtraction                -> 135: "sub135"
-333: push_constant 2.0          -> 468: "c134"
-334: subtraction                -> 134: "sub134"
-335: push_constant 2.0          -> 469: "c133"
-336: subtraction                -> 133: "sub133"
-337: push_constant 2.0          -> 470: "c132"
-338: subtraction                -> 132: "sub132"
-339: push_constant 2.0          -> 471: "c131"
-340: subtraction                -> 131: "sub131"
-341: push_constant 2.0          -> 472: "c130"
-342: subtraction                -> 130: "sub130"
-343: push_constant 2.0          -> 473: "c129"
-344: subtraction                -> 129: "sub129"
-345: push_constant 2.0          -> 474: "c128"
-346: subtraction                -> 128: "sub128"
-347: push_constant 2.0          -> 475: "c127"
-348: subtraction                -> 127: "sub127"
-349: push_constant 2.0          -> 476: "c126"
-350: subtraction                -> 126: "sub126"
-351: push_constant 2.0          -> 477: "c125"
-352: subtraction                -> 125: "sub125"
-353: push_constant 2.0          -> 478: "c124"
-354: subtraction                -> 124: "sub124"
-355: push_constant 2.0          -> 479: "c123"
-356: subtraction                -> 123: "sub123"
-357: push_constant 2.0          -> 480: "c122"
-358: subtraction                -> 122: "sub122"
-359: push_constant 2.0          -> 481: "c121"
-360: subtraction                -> 121: "sub121"
-361: push_constant 2.0          -> 482: "c120"
-362: subtraction                -> 120: "sub120"
-363: push_constant 2.0          -> 483: "c119"
-364: subtraction                -> 119: "sub119"
-365: push_constant 2.0          -> 484: "c118"
-366: subtraction                -> 118: "sub118"
-367: push_constant 2.0          -> 485: "c117"
-368: subtraction                -> 117: "sub117"
-369: push_constant 2.0          -> 486: "c116"
-370: subtraction                -> 116: "sub116"
-371: push_constant 2.0          -> 487: "c115"
-372: subtraction                -> 115: "sub115"
-373: push_constant 2.0          -> 488: "c114"
-374: subtraction                -> 114: "sub114"
-375: push_constant 2.0          -> 489: "c113"
-376: subtraction                -> 113: "sub113"
-377: push_constant 2.0          -> 490: "c112"
-378: subtraction                -> 112: "sub112"
-379: push_constant 2.0          -> 491: "c111"
-380: subtraction                -> 111: "sub111"
-381: push_constant 2.0          -> 492: "c110"
-382: subtraction                -> 110: "sub110"
-383: push_constant 2.0          -> 493: "c109"
-384: subtraction                -> 109: "sub109"
-385: push_constant 2.0          -> 494: "c108"
-386: subtraction                -> 108: "sub108"
-387: push_constant 2.0          -> 495: "c107"
-388: subtraction                -> 107: "sub107"
-389: push_constant 2.0          -> 496: "c106"
-390: subtraction                -> 106: "sub106"
-391: push_constant 2.0          -> 497: "c105"
-392: subtraction                -> 105: "sub105"
-393: push_constant 2.0          -> 498: "c104"
-394: subtraction                -> 104: "sub104"
-395: push_constant 2.0          -> 499: "c103"
-396: subtraction                -> 103: "sub103"
-397: push_constant 2.0          -> 500: "c102"
-398: subtraction                -> 102: "sub102"
-399: push_constant 2.0          -> 501: "c101"
-400: subtraction                -> 101: "sub101"
-401: push_constant 2.0          -> 502: "c100"
-402: subtraction                -> 100: "sub100"
-403: push_constant 2.0          -> 503: "c99"
-404: subtraction                -> 99: "sub99"
-405: push_constant 2.0          -> 504: "c98"
-406: subtraction                -> 98: "sub98"
-407: push_constant 2.0          -> 505: "c97"
-408: subtraction                -> 97: "sub97"
-409: push_constant 2.0          -> 506: "c96"
-410: subtraction                -> 96: "sub96"
-411: push_constant 2.0          -> 507: "c95"
-412: subtraction                -> 95: "sub95"
-413: push_constant 2.0          -> 508: "c94"
-414: subtraction                -> 94: "sub94"
-415: push_constant 2.0          -> 509: "c93"
-416: subtraction                -> 93: "sub93"
-417: push_constant 2.0          -> 510: "c92"
-418: subtraction                -> 92: "sub92"
-419: push_constant 2.0          -> 511: "c91"
-420: subtraction                -> 91: "sub91"
-421: push_constant 2.0          -> 512: "c90"
-422: subtraction                -> 90: "sub90"
-423: push_constant 2.0          -> 513: "c89"
-424: subtraction                -> 89: "sub89"
-425: push_constant 2.0          -> 514: "c88"
-426: subtraction                -> 88: "sub88"
-427: push_constant 2.0          -> 515: "c87"
-428: subtraction                -> 87: "sub87"
-429: push_constant 2.0          -> 516: "c86"
-430: subtraction                -> 86: "sub86"
-431: push_constant 2.0          -> 517: "c85"
-432: subtraction                -> 85: "sub85"
-433: push_constant 2.0          -> 518: "c84"
-434: subtraction                -> 84: "sub84"
-435: push_constant 2.0          -> 519: "c83"
-436: subtraction                -> 83: "sub83"
-437: push_constant 2.0          -> 520: "c82"
-438: subtraction                -> 82: "sub82"
-439: push_constant 2.0          -> 521: "c81"
-440: subtraction                -> 81: "sub81"
-441: push_constant 2.0          -> 522: "c80"
-442: subtraction                -> 80: "sub80"
-443: push_constant 2.0          -> 523: "c79"
-444: subtraction                -> 79: "sub79"
-445: push_constant 2.0          -> 524: "c78"
-446: subtraction                -> 78: "sub78"
-447: push_constant 2.0          -> 525: "c77"
-448: subtraction                -> 77: "sub77"
-449: push_constant 2.0          -> 526: "c76"
-450: subtraction                -> 76: "sub76"
-451: push_constant 2.0          -> 527: "c75"
-452: subtraction                -> 75: "sub75"
-453: push_constant 2.0          -> 528: "c74"
-454: subtraction                -> 74: "sub74"
-455: push_constant 2.0          -> 529: "c73"
-456: subtraction                -> 73: "sub73"
-457: push_constant 2.0          -> 530: "c72"
-458: subtraction                -> 72: "sub72"
-459: push_constant 2.0          -> 531: "c71"
-460: subtraction                -> 71: "sub71"
-461: push_constant 2.0          -> 532: "c70"
-462: subtraction                -> 70: "sub70"
-463: push_constant 2.0          -> 533: "c69"
-464: subtraction                -> 69: "sub69"
-465: push_constant 2.0          -> 534: "c68"
-466: subtraction                -> 68: "sub68"
-467: push_constant 2.0          -> 535: "c67"
-468: subtraction                -> 67: "sub67"
-469: push_constant 2.0          -> 536: "c66"
-470: subtraction                -> 66: "sub66"
-471: push_constant 2.0          -> 537: "c65"
-472: subtraction                -> 65: "sub65"
-473: push_constant 2.0          -> 538: "c64"
-474: subtraction                -> 64: "sub64"
-475: push_constant 2.0          -> 539: "c63"
-476: subtraction                -> 63: "sub63"
-477: push_constant 2.0          -> 540: "c62"
-478: subtraction                -> 62: "sub62"
-479: push_constant 2.0          -> 541: "c61"
-480: subtraction                -> 61: "sub61"
-481: push_constant 2.0          -> 542: "c60"
-482: subtraction                -> 60: "sub60"
-483: push_constant 2.0          -> 543: "c59"
-484: subtraction                -> 59: "sub59"
-485: push_constant 2.0          -> 544: "c58"
-486: subtraction                -> 58: "sub58"
-487: push_constant 2.0          -> 545: "c57"
-488: subtraction                -> 57: "sub57"
-489: push_constant 2.0          -> 546: "c56"
-490: subtraction                -> 56: "sub56"
-491: push_constant 2.0          -> 547: "c55"
-492: subtraction                -> 55: "sub55"
-493: push_constant 2.0          -> 548: "c54"
-494: subtraction                -> 54: "sub54"
-495: push_constant 2.0          -> 549: "c53"
-496: subtraction                -> 53: "sub53"
-497: push_constant 2.0          -> 550: "c52"
-498: subtraction                -> 52: "sub52"
-499: push_constant 2.0          -> 551: "c51"
-500: subtraction                -> 51: "sub51"
-501: push_constant 2.0          -> 552: "c50"
-502: subtraction                -> 50: "sub50"
-503: push_constant 2.0          -> 553: "c49"
-504: subtraction                -> 49: "sub49"
-505: push_constant 2.0          -> 554: "c48"
-506: subtraction                -> 48: "sub48"
-507: push_constant 2.0          -> 555: "c47"
-508: subtraction                -> 47: "sub47"
-509: push_constant 2.0          -> 556: "c46"
-510: subtraction                -> 46: "sub46"
-511: push_constant 2.0          -> 557: "c45"
-512: subtraction                -> 45: "sub45"
-513: push_constant 2.0          -> 558: "c44"
-514: subtraction                -> 44: "sub44"
-515: push_constant 2.0          -> 559: "c43"
-516: subtraction                -> 43: "sub43"
-517: push_constant 2.0          -> 560: "c42"
-518: subtraction                -> 42: "sub42"
-519: push_constant 2.0          -> 561: "c41"
-520: subtraction                -> 41: "sub41"
-521: push_constant 2.0          -> 562: "c40"
-522: subtraction                -> 40: "sub40"
-523: push_constant 2.0          -> 563: "c39"
-524: subtraction                -> 39: "sub39"
-525: push_constant 2.0          -> 564: "c38"
-526: subtraction                -> 38: "sub38"
-527: push_constant 2.0          -> 565: "c37"
-528: subtraction                -> 37: "sub37"
-529: push_constant 2.0          -> 566: "c36"
-530: subtraction                -> 36: "sub36"
-531: push_constant 2.0          -> 567: "c35"
-532: subtraction                -> 35: "sub35"
-533: push_constant 2.0          -> 568: "c34"
-534: subtraction                -> 34: "sub34"
-535: push_constant 2.0          -> 569: "c33"
-536: subtraction                -> 33: "sub33"
-537: push_constant 2.0          -> 570: "c32"
-538: subtraction                -> 32: "sub32"
-539: push_constant 2.0          -> 571: "c31"
-540: subtraction                -> 31: "sub31"
-541: push_constant 2.0          -> 572: "c30"
-542: subtraction                -> 30: "sub30"
-543: push_constant 2.0          -> 573: "c29"
-544: subtraction                -> 29: "sub29"
-545: push_constant 2.0          -> 574: "c28"
-546: subtraction                -> 28: "sub28"
-547: push_constant 2.0          -> 575: "c27"
-548: subtraction                -> 27: "sub27"
-549: push_constant 2.0          -> 576: "c26"
-550: subtraction                -> 26: "sub26"
-551: push_constant 2.0          -> 577: "c25"
-552: subtraction                -> 25: "sub25"
-553: push_constant 2.0          -> 578: "c24"
-554: subtraction                -> 24: "sub24"
-555: push_constant 2.0          -> 579: "c23"
-556: subtraction                -> 23: "sub23"
-557: push_constant 2.0          -> 580: "c22"
-558: subtraction                -> 22: "sub22"
-559: push_constant 2.0          -> 581: "c21"
-560: subtraction                -> 21: "sub21"
-561: push_constant 2.0          -> 582: "c20"
-562: subtraction                -> 20: "sub20"
-563: push_constant 2.0          -> 583: "c19"
-564: subtraction                -> 19: "sub19"
-565: push_constant 2.0          -> 584: "c18"
-566: subtraction                -> 18: "sub18"
-567: push_constant 2.0          -> 585: "c17"
-568: subtraction                -> 17: "sub17"
-569: push_constant 2.0          -> 586: "c16"
-570: subtraction                -> 16: "sub16"
-571: push_constant 2.0          -> 587: "c15"
-572: subtraction                -> 15: "sub15"
-573: push_constant 2.0          -> 588: "c14"
-574: subtraction                -> 14: "sub14"
-575: push_constant 2.0          -> 589: "c13"
-576: subtraction                -> 13: "sub13"
-577: push_constant 2.0          -> 590: "c12"
-578: subtraction                -> 12: "sub12"
-579: push_constant 2.0          -> 591: "c11"
-580: subtraction                -> 11: "sub11"
-581: push_constant 2.0          -> 592: "c10"
-582: subtraction                -> 10: "sub10"
-583: push_constant 2.0          -> 593: "c9"
-584: subtraction                -> 9: "sub9"
-585: push_constant 2.0          -> 594: "c8"
-586: subtraction                -> 8: "sub8"
-587: push_constant 2.0          -> 595: "c7"
-588: subtraction                -> 7: "sub7"
-589: push_constant 2.0          -> 596: "c6"
-590: subtraction                -> 6: "sub6"
-591: push_constant 2.0          -> 597: "c5"
-592: subtraction                -> 5: "sub5"
-593: push_constant 2.0          -> 598: "c4"
-594: subtraction                -> 4: "sub4"
-595: push_constant 2.0          -> 599: "c3"
-596: subtraction                -> 3: "sub3"
-597: push_constant 2.0          -> 600: "c2"
-598: subtraction                -> 2: "sub2"
-599: push_constant 2.0          -> 601: "c1"
-600: subtraction                -> 1: "sub1"
-601: forward_value              -> 0: "0"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 0.0.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-compile.cpp:41                          : Compiling code...
-compile.cpp:47                          : Compiled code:
-==============================================
-> Code stats
-==============================================
-Input count: 0
-Output count: 2
-Instruction count: 1008
-Required stack size: 3
-Delay count: 0
-Result count: 1006
-Custom operation count: 0
-Custom source count: 0
-==============================================
-> Delays
-==============================================
-==============================================
-> Result keys
-==============================================
- 0: "0"
- 1: "bfly1.0"
- 2: "add1"
- 3: "add2"
- 4: "add3"
- 5: "add4"
- 6: "add5"
- 7: "add6"
- 8: "add7"
- 9: "add8"
-10: "add9"
-11: "add10"
-12: "add11"
-13: "add12"
-14: "add13"
-15: "add14"
-16: "add15"
-17: "add16"
-18: "add17"
-19: "add18"
-20: "add19"
-21: "add20"
-22: "add21"
-23: "add22"
-24: "add23"
-25: "add24"
-26: "add25"
-27: "add26"
-28: "add27"
-29: "add28"
-30: "add29"
-31: "add30"
-32: "add31"
-33: "add32"
-34: "add33"
-35: "add34"
-36: "add35"
-37: "add36"
-38: "add37"
-39: "add38"
-40: "add39"
-41: "add40"
-42: "add41"
-43: "add42"
-44: "add43"
-45: "add44"
-46: "add45"
-47: "add46"
-48: "add47"
-49: "add48"
-50: "add49"
-51: "add50"
-52: "add51"
-53: "add52"
-54: "add53"
-55: "add54"
-56: "add55"
-57: "add56"
-58: "add57"
-59: "add58"
-60: "add59"
-61: "add60"
-62: "add61"
-63: "add62"
-64: "add63"
-65: "add64"
-66: "add65"
-67: "add66"
-68: "add67"
-69: "add68"
-70: "add69"
-71: "add70"
-72: "add71"
-73: "add72"
-74: "add73"
-75: "add74"
-76: "add75"
-77: "add76"
-78: "add77"
-79: "add78"
-80: "add79"
-81: "add80"
-82: "add81"
-83: "add82"
-84: "add83"
-85: "add84"
-86: "add85"
-87: "add86"
-88: "add87"
-89: "add88"
-90: "add89"
-91: "add90"
-92: "add91"
-93: "add92"
-94: "add93"
-95: "add94"
-96: "add95"
-97: "add96"
-98: "add97"
-99: "add98"
-100: "add99"
-101: "add100"
-102: "add101"
-103: "add102"
-104: "add103"
-105: "add104"
-106: "add105"
-107: "add106"
-108: "add107"
-109: "add108"
-110: "add109"
-111: "add110"
-112: "add111"
-113: "add112"
-114: "add113"
-115: "add114"
-116: "add115"
-117: "add116"
-118: "add117"
-119: "add118"
-120: "add119"
-121: "add120"
-122: "add121"
-123: "add122"
-124: "add123"
-125: "add124"
-126: "add125"
-127: "add126"
-128: "add127"
-129: "add128"
-130: "add129"
-131: "add130"
-132: "add131"
-133: "add132"
-134: "add133"
-135: "add134"
-136: "add135"
-137: "add136"
-138: "add137"
-139: "add138"
-140: "add139"
-141: "add140"
-142: "add141"
-143: "add142"
-144: "add143"
-145: "add144"
-146: "add145"
-147: "add146"
-148: "add147"
-149: "add148"
-150: "add149"
-151: "add150"
-152: "add151"
-153: "add152"
-154: "add153"
-155: "add154"
-156: "add155"
-157: "add156"
-158: "add157"
-159: "add158"
-160: "add159"
-161: "add160"
-162: "add161"
-163: "add162"
-164: "add163"
-165: "add164"
-166: "add165"
-167: "add166"
-168: "add167"
-169: "add168"
-170: "add169"
-171: "add170"
-172: "add171"
-173: "add172"
-174: "add173"
-175: "add174"
-176: "add175"
-177: "add176"
-178: "add177"
-179: "add178"
-180: "add179"
-181: "add180"
-182: "add181"
-183: "add182"
-184: "add183"
-185: "add184"
-186: "add185"
-187: "add186"
-188: "add187"
-189: "add188"
-190: "add189"
-191: "add190"
-192: "add191"
-193: "add192"
-194: "add193"
-195: "add194"
-196: "add195"
-197: "add196"
-198: "add197"
-199: "add198"
-200: "add199"
-201: "add200"
-202: "add201"
-203: "add202"
-204: "add203"
-205: "add204"
-206: "add205"
-207: "add206"
-208: "add207"
-209: "add208"
-210: "add209"
-211: "add210"
-212: "add211"
-213: "add212"
-214: "add213"
-215: "add214"
-216: "add215"
-217: "add216"
-218: "add217"
-219: "add218"
-220: "add219"
-221: "add220"
-222: "add221"
-223: "add222"
-224: "add223"
-225: "add224"
-226: "add225"
-227: "add226"
-228: "add227"
-229: "add228"
-230: "add229"
-231: "add230"
-232: "add231"
-233: "add232"
-234: "add233"
-235: "add234"
-236: "add235"
-237: "add236"
-238: "add237"
-239: "add238"
-240: "add239"
-241: "add240"
-242: "add241"
-243: "add242"
-244: "add243"
-245: "add244"
-246: "add245"
-247: "add246"
-248: "add247"
-249: "add248"
-250: "add249"
-251: "add250"
-252: "c501"
-253: "c502"
-254: "c500"
-255: "c499"
-256: "c498"
-257: "c497"
-258: "c496"
-259: "c495"
-260: "c494"
-261: "c493"
-262: "c492"
-263: "c491"
-264: "c490"
-265: "c489"
-266: "c488"
-267: "c487"
-268: "c486"
-269: "c485"
-270: "c484"
-271: "c483"
-272: "c482"
-273: "c481"
-274: "c480"
-275: "c479"
-276: "c478"
-277: "c477"
-278: "c476"
-279: "c475"
-280: "c474"
-281: "c473"
-282: "c472"
-283: "c471"
-284: "c470"
-285: "c469"
-286: "c468"
-287: "c467"
-288: "c466"
-289: "c465"
-290: "c464"
-291: "c463"
-292: "c462"
-293: "c461"
-294: "c460"
-295: "c459"
-296: "c458"
-297: "c457"
-298: "c456"
-299: "c455"
-300: "c454"
-301: "c453"
-302: "c452"
-303: "c451"
-304: "c450"
-305: "c449"
-306: "c448"
-307: "c447"
-308: "c446"
-309: "c445"
-310: "c444"
-311: "c443"
-312: "c442"
-313: "c441"
-314: "c440"
-315: "c439"
-316: "c438"
-317: "c437"
-318: "c436"
-319: "c435"
-320: "c434"
-321: "c433"
-322: "c432"
-323: "c431"
-324: "c430"
-325: "c429"
-326: "c428"
-327: "c427"
-328: "c426"
-329: "c425"
-330: "c424"
-331: "c423"
-332: "c422"
-333: "c421"
-334: "c420"
-335: "c419"
-336: "c418"
-337: "c417"
-338: "c416"
-339: "c415"
-340: "c414"
-341: "c413"
-342: "c412"
-343: "c411"
-344: "c410"
-345: "c409"
-346: "c408"
-347: "c407"
-348: "c406"
-349: "c405"
-350: "c404"
-351: "c403"
-352: "c402"
-353: "c401"
-354: "c400"
-355: "c399"
-356: "c398"
-357: "c397"
-358: "c396"
-359: "c395"
-360: "c394"
-361: "c393"
-362: "c392"
-363: "c391"
-364: "c390"
-365: "c389"
-366: "c388"
-367: "c387"
-368: "c386"
-369: "c385"
-370: "c384"
-371: "c383"
-372: "c382"
-373: "c381"
-374: "c380"
-375: "c379"
-376: "c378"
-377: "c377"
-378: "c376"
-379: "c375"
-380: "c374"
-381: "c373"
-382: "c372"
-383: "c371"
-384: "c370"
-385: "c369"
-386: "c368"
-387: "c367"
-388: "c366"
-389: "c365"
-390: "c364"
-391: "c363"
-392: "c362"
-393: "c361"
-394: "c360"
-395: "c359"
-396: "c358"
-397: "c357"
-398: "c356"
-399: "c355"
-400: "c354"
-401: "c353"
-402: "c352"
-403: "c351"
-404: "c350"
-405: "c349"
-406: "c348"
-407: "c347"
-408: "c346"
-409: "c345"
-410: "c344"
-411: "c343"
-412: "c342"
-413: "c341"
-414: "c340"
-415: "c339"
-416: "c338"
-417: "c337"
-418: "c336"
-419: "c335"
-420: "c334"
-421: "c333"
-422: "c332"
-423: "c331"
-424: "c330"
-425: "c329"
-426: "c328"
-427: "c327"
-428: "c326"
-429: "c325"
-430: "c324"
-431: "c323"
-432: "c322"
-433: "c321"
-434: "c320"
-435: "c319"
-436: "c318"
-437: "c317"
-438: "c316"
-439: "c315"
-440: "c314"
-441: "c313"
-442: "c312"
-443: "c311"
-444: "c310"
-445: "c309"
-446: "c308"
-447: "c307"
-448: "c306"
-449: "c305"
-450: "c304"
-451: "c303"
-452: "c302"
-453: "c301"
-454: "c300"
-455: "c299"
-456: "c298"
-457: "c297"
-458: "c296"
-459: "c295"
-460: "c294"
-461: "c293"
-462: "c292"
-463: "c291"
-464: "c290"
-465: "c289"
-466: "c288"
-467: "c287"
-468: "c286"
-469: "c285"
-470: "c284"
-471: "c283"
-472: "c282"
-473: "c281"
-474: "c280"
-475: "c279"
-476: "c278"
-477: "c277"
-478: "c276"
-479: "c275"
-480: "c274"
-481: "c273"
-482: "c272"
-483: "c271"
-484: "c270"
-485: "c269"
-486: "c268"
-487: "c267"
-488: "c266"
-489: "c265"
-490: "c264"
-491: "c263"
-492: "c262"
-493: "c261"
-494: "c260"
-495: "c259"
-496: "c258"
-497: "c257"
-498: "c256"
-499: "c255"
-500: "c254"
-501: "c253"
-502: "c252"
-503: "sub1"
-504: "sub2"
-505: "sub3"
-506: "sub4"
-507: "sub5"
-508: "sub6"
-509: "sub7"
-510: "sub8"
-511: "sub9"
-512: "sub10"
-513: "sub11"
-514: "sub12"
-515: "sub13"
-516: "sub14"
-517: "sub15"
-518: "sub16"
-519: "sub17"
-520: "sub18"
-521: "sub19"
-522: "sub20"
-523: "sub21"
-524: "sub22"
-525: "sub23"
-526: "sub24"
-527: "sub25"
-528: "sub26"
-529: "sub27"
-530: "sub28"
-531: "sub29"
-532: "sub30"
-533: "sub31"
-534: "sub32"
-535: "sub33"
-536: "sub34"
-537: "sub35"
-538: "sub36"
-539: "sub37"
-540: "sub38"
-541: "sub39"
-542: "sub40"
-543: "sub41"
-544: "sub42"
-545: "sub43"
-546: "sub44"
-547: "sub45"
-548: "sub46"
-549: "sub47"
-550: "sub48"
-551: "sub49"
-552: "sub50"
-553: "sub51"
-554: "sub52"
-555: "sub53"
-556: "sub54"
-557: "sub55"
-558: "sub56"
-559: "sub57"
-560: "sub58"
-561: "sub59"
-562: "sub60"
-563: "sub61"
-564: "sub62"
-565: "sub63"
-566: "sub64"
-567: "sub65"
-568: "sub66"
-569: "sub67"
-570: "sub68"
-571: "sub69"
-572: "sub70"
-573: "sub71"
-574: "sub72"
-575: "sub73"
-576: "sub74"
-577: "sub75"
-578: "sub76"
-579: "sub77"
-580: "sub78"
-581: "sub79"
-582: "sub80"
-583: "sub81"
-584: "sub82"
-585: "sub83"
-586: "sub84"
-587: "sub85"
-588: "sub86"
-589: "sub87"
-590: "sub88"
-591: "sub89"
-592: "sub90"
-593: "sub91"
-594: "sub92"
-595: "sub93"
-596: "sub94"
-597: "sub95"
-598: "sub96"
-599: "sub97"
-600: "sub98"
-601: "sub99"
-602: "sub100"
-603: "sub101"
-604: "sub102"
-605: "sub103"
-606: "sub104"
-607: "sub105"
-608: "sub106"
-609: "sub107"
-610: "sub108"
-611: "sub109"
-612: "sub110"
-613: "sub111"
-614: "sub112"
-615: "sub113"
-616: "sub114"
-617: "sub115"
-618: "sub116"
-619: "sub117"
-620: "sub118"
-621: "sub119"
-622: "sub120"
-623: "sub121"
-624: "sub122"
-625: "sub123"
-626: "sub124"
-627: "sub125"
-628: "sub126"
-629: "sub127"
-630: "sub128"
-631: "sub129"
-632: "sub130"
-633: "sub131"
-634: "sub132"
-635: "sub133"
-636: "sub134"
-637: "sub135"
-638: "sub136"
-639: "sub137"
-640: "sub138"
-641: "sub139"
-642: "sub140"
-643: "sub141"
-644: "sub142"
-645: "sub143"
-646: "sub144"
-647: "sub145"
-648: "sub146"
-649: "sub147"
-650: "sub148"
-651: "sub149"
-652: "sub150"
-653: "sub151"
-654: "sub152"
-655: "sub153"
-656: "sub154"
-657: "sub155"
-658: "sub156"
-659: "sub157"
-660: "sub158"
-661: "sub159"
-662: "sub160"
-663: "sub161"
-664: "sub162"
-665: "sub163"
-666: "sub164"
-667: "sub165"
-668: "sub166"
-669: "sub167"
-670: "sub168"
-671: "sub169"
-672: "sub170"
-673: "sub171"
-674: "sub172"
-675: "sub173"
-676: "sub174"
-677: "sub175"
-678: "sub176"
-679: "sub177"
-680: "sub178"
-681: "sub179"
-682: "sub180"
-683: "sub181"
-684: "sub182"
-685: "sub183"
-686: "sub184"
-687: "sub185"
-688: "sub186"
-689: "sub187"
-690: "sub188"
-691: "sub189"
-692: "sub190"
-693: "sub191"
-694: "sub192"
-695: "sub193"
-696: "sub194"
-697: "sub195"
-698: "sub196"
-699: "sub197"
-700: "sub198"
-701: "sub199"
-702: "sub200"
-703: "sub201"
-704: "sub202"
-705: "sub203"
-706: "sub204"
-707: "sub205"
-708: "sub206"
-709: "sub207"
-710: "sub208"
-711: "sub209"
-712: "sub210"
-713: "sub211"
-714: "sub212"
-715: "sub213"
-716: "sub214"
-717: "sub215"
-718: "sub216"
-719: "sub217"
-720: "sub218"
-721: "sub219"
-722: "sub220"
-723: "sub221"
-724: "sub222"
-725: "sub223"
-726: "sub224"
-727: "sub225"
-728: "sub226"
-729: "sub227"
-730: "sub228"
-731: "sub229"
-732: "sub230"
-733: "sub231"
-734: "sub232"
-735: "sub233"
-736: "sub234"
-737: "sub235"
-738: "sub236"
-739: "sub237"
-740: "sub238"
-741: "sub239"
-742: "sub240"
-743: "sub241"
-744: "sub242"
-745: "sub243"
-746: "sub244"
-747: "sub245"
-748: "sub246"
-749: "sub247"
-750: "sub248"
-751: "sub249"
-752: "sub250"
-753: "c250"
-754: "c251"
-755: "c249"
-756: "c248"
-757: "c247"
-758: "c246"
-759: "c245"
-760: "c244"
-761: "c243"
-762: "c242"
-763: "c241"
-764: "c240"
-765: "c239"
-766: "c238"
-767: "c237"
-768: "c236"
-769: "c235"
-770: "c234"
-771: "c233"
-772: "c232"
-773: "c231"
-774: "c230"
-775: "c229"
-776: "c228"
-777: "c227"
-778: "c226"
-779: "c225"
-780: "c224"
-781: "c223"
-782: "c222"
-783: "c221"
-784: "c220"
-785: "c219"
-786: "c218"
-787: "c217"
-788: "c216"
-789: "c215"
-790: "c214"
-791: "c213"
-792: "c212"
-793: "c211"
-794: "c210"
-795: "c209"
-796: "c208"
-797: "c207"
-798: "c206"
-799: "c205"
-800: "c204"
-801: "c203"
-802: "c202"
-803: "c201"
-804: "c200"
-805: "c199"
-806: "c198"
-807: "c197"
-808: "c196"
-809: "c195"
-810: "c194"
-811: "c193"
-812: "c192"
-813: "c191"
-814: "c190"
-815: "c189"
-816: "c188"
-817: "c187"
-818: "c186"
-819: "c185"
-820: "c184"
-821: "c183"
-822: "c182"
-823: "c181"
-824: "c180"
-825: "c179"
-826: "c178"
-827: "c177"
-828: "c176"
-829: "c175"
-830: "c174"
-831: "c173"
-832: "c172"
-833: "c171"
-834: "c170"
-835: "c169"
-836: "c168"
-837: "c167"
-838: "c166"
-839: "c165"
-840: "c164"
-841: "c163"
-842: "c162"
-843: "c161"
-844: "c160"
-845: "c159"
-846: "c158"
-847: "c157"
-848: "c156"
-849: "c155"
-850: "c154"
-851: "c153"
-852: "c152"
-853: "c151"
-854: "c150"
-855: "c149"
-856: "c148"
-857: "c147"
-858: "c146"
-859: "c145"
-860: "c144"
-861: "c143"
-862: "c142"
-863: "c141"
-864: "c140"
-865: "c139"
-866: "c138"
-867: "c137"
-868: "c136"
-869: "c135"
-870: "c134"
-871: "c133"
-872: "c132"
-873: "c131"
-874: "c130"
-875: "c129"
-876: "c128"
-877: "c127"
-878: "c126"
-879: "c125"
-880: "c124"
-881: "c123"
-882: "c122"
-883: "c121"
-884: "c120"
-885: "c119"
-886: "c118"
-887: "c117"
-888: "c116"
-889: "c115"
-890: "c114"
-891: "c113"
-892: "c112"
-893: "c111"
-894: "c110"
-895: "c109"
-896: "c108"
-897: "c107"
-898: "c106"
-899: "c105"
-900: "c104"
-901: "c103"
-902: "c102"
-903: "c101"
-904: "c100"
-905: "c99"
-906: "c98"
-907: "c97"
-908: "c96"
-909: "c95"
-910: "c94"
-911: "c93"
-912: "c92"
-913: "c91"
-914: "c90"
-915: "c89"
-916: "c88"
-917: "c87"
-918: "c86"
-919: "c85"
-920: "c84"
-921: "c83"
-922: "c82"
-923: "c81"
-924: "c80"
-925: "c79"
-926: "c78"
-927: "c77"
-928: "c76"
-929: "c75"
-930: "c74"
-931: "c73"
-932: "c72"
-933: "c71"
-934: "c70"
-935: "c69"
-936: "c68"
-937: "c67"
-938: "c66"
-939: "c65"
-940: "c64"
-941: "c63"
-942: "c62"
-943: "c61"
-944: "c60"
-945: "c59"
-946: "c58"
-947: "c57"
-948: "c56"
-949: "c55"
-950: "c54"
-951: "c53"
-952: "c52"
-953: "c51"
-954: "c50"
-955: "c49"
-956: "c48"
-957: "c47"
-958: "c46"
-959: "c45"
-960: "c44"
-961: "c43"
-962: "c42"
-963: "c41"
-964: "c40"
-965: "c39"
-966: "c38"
-967: "c37"
-968: "c36"
-969: "c35"
-970: "c34"
-971: "c33"
-972: "c32"
-973: "c31"
-974: "c30"
-975: "c29"
-976: "c28"
-977: "c27"
-978: "c26"
-979: "c25"
-980: "c24"
-981: "c23"
-982: "c22"
-983: "c21"
-984: "c20"
-985: "c19"
-986: "c18"
-987: "c17"
-988: "c16"
-989: "c15"
-990: "c14"
-991: "c13"
-992: "c12"
-993: "c11"
-994: "c10"
-995: "c9"
-996: "c8"
-997: "c7"
-998: "c6"
-999: "c5"
-1000: "c4"
-1001: "c3"
-1002: "c2"
-1003: "c1"
-1004: "1"
-1005: "bfly1.1"
-==============================================
-> Instructions
-==============================================
- 0: push_constant 1.0          -> 252: "c501"
- 1: push_constant 1.0          -> 253: "c502"
- 2: addition                   -> 251: "add250"
- 3: push_constant 2.0          -> 254: "c500"
- 4: addition                   -> 250: "add249"
- 5: push_constant 2.0          -> 255: "c499"
- 6: addition                   -> 249: "add248"
- 7: push_constant 2.0          -> 256: "c498"
- 8: addition                   -> 248: "add247"
- 9: push_constant 2.0          -> 257: "c497"
-10: addition                   -> 247: "add246"
-11: push_constant 2.0          -> 258: "c496"
-12: addition                   -> 246: "add245"
-13: push_constant 2.0          -> 259: "c495"
-14: addition                   -> 245: "add244"
-15: push_constant 2.0          -> 260: "c494"
-16: addition                   -> 244: "add243"
-17: push_constant 2.0          -> 261: "c493"
-18: addition                   -> 243: "add242"
-19: push_constant 2.0          -> 262: "c492"
-20: addition                   -> 242: "add241"
-21: push_constant 2.0          -> 263: "c491"
-22: addition                   -> 241: "add240"
-23: push_constant 2.0          -> 264: "c490"
-24: addition                   -> 240: "add239"
-25: push_constant 2.0          -> 265: "c489"
-26: addition                   -> 239: "add238"
-27: push_constant 2.0          -> 266: "c488"
-28: addition                   -> 238: "add237"
-29: push_constant 2.0          -> 267: "c487"
-30: addition                   -> 237: "add236"
-31: push_constant 2.0          -> 268: "c486"
-32: addition                   -> 236: "add235"
-33: push_constant 2.0          -> 269: "c485"
-34: addition                   -> 235: "add234"
-35: push_constant 2.0          -> 270: "c484"
-36: addition                   -> 234: "add233"
-37: push_constant 2.0          -> 271: "c483"
-38: addition                   -> 233: "add232"
-39: push_constant 2.0          -> 272: "c482"
-40: addition                   -> 232: "add231"
-41: push_constant 2.0          -> 273: "c481"
-42: addition                   -> 231: "add230"
-43: push_constant 2.0          -> 274: "c480"
-44: addition                   -> 230: "add229"
-45: push_constant 2.0          -> 275: "c479"
-46: addition                   -> 229: "add228"
-47: push_constant 2.0          -> 276: "c478"
-48: addition                   -> 228: "add227"
-49: push_constant 2.0          -> 277: "c477"
-50: addition                   -> 227: "add226"
-51: push_constant 2.0          -> 278: "c476"
-52: addition                   -> 226: "add225"
-53: push_constant 2.0          -> 279: "c475"
-54: addition                   -> 225: "add224"
-55: push_constant 2.0          -> 280: "c474"
-56: addition                   -> 224: "add223"
-57: push_constant 2.0          -> 281: "c473"
-58: addition                   -> 223: "add222"
-59: push_constant 2.0          -> 282: "c472"
-60: addition                   -> 222: "add221"
-61: push_constant 2.0          -> 283: "c471"
-62: addition                   -> 221: "add220"
-63: push_constant 2.0          -> 284: "c470"
-64: addition                   -> 220: "add219"
-65: push_constant 2.0          -> 285: "c469"
-66: addition                   -> 219: "add218"
-67: push_constant 2.0          -> 286: "c468"
-68: addition                   -> 218: "add217"
-69: push_constant 2.0          -> 287: "c467"
-70: addition                   -> 217: "add216"
-71: push_constant 2.0          -> 288: "c466"
-72: addition                   -> 216: "add215"
-73: push_constant 2.0          -> 289: "c465"
-74: addition                   -> 215: "add214"
-75: push_constant 2.0          -> 290: "c464"
-76: addition                   -> 214: "add213"
-77: push_constant 2.0          -> 291: "c463"
-78: addition                   -> 213: "add212"
-79: push_constant 2.0          -> 292: "c462"
-80: addition                   -> 212: "add211"
-81: push_constant 2.0          -> 293: "c461"
-82: addition                   -> 211: "add210"
-83: push_constant 2.0          -> 294: "c460"
-84: addition                   -> 210: "add209"
-85: push_constant 2.0          -> 295: "c459"
-86: addition                   -> 209: "add208"
-87: push_constant 2.0          -> 296: "c458"
-88: addition                   -> 208: "add207"
-89: push_constant 2.0          -> 297: "c457"
-90: addition                   -> 207: "add206"
-91: push_constant 2.0          -> 298: "c456"
-92: addition                   -> 206: "add205"
-93: push_constant 2.0          -> 299: "c455"
-94: addition                   -> 205: "add204"
-95: push_constant 2.0          -> 300: "c454"
-96: addition                   -> 204: "add203"
-97: push_constant 2.0          -> 301: "c453"
-98: addition                   -> 203: "add202"
-99: push_constant 2.0          -> 302: "c452"
-100: addition                   -> 202: "add201"
-101: push_constant 2.0          -> 303: "c451"
-102: addition                   -> 201: "add200"
-103: push_constant 2.0          -> 304: "c450"
-104: addition                   -> 200: "add199"
-105: push_constant 2.0          -> 305: "c449"
-106: addition                   -> 199: "add198"
-107: push_constant 2.0          -> 306: "c448"
-108: addition                   -> 198: "add197"
-109: push_constant 2.0          -> 307: "c447"
-110: addition                   -> 197: "add196"
-111: push_constant 2.0          -> 308: "c446"
-112: addition                   -> 196: "add195"
-113: push_constant 2.0          -> 309: "c445"
-114: addition                   -> 195: "add194"
-115: push_constant 2.0          -> 310: "c444"
-116: addition                   -> 194: "add193"
-117: push_constant 2.0          -> 311: "c443"
-118: addition                   -> 193: "add192"
-119: push_constant 2.0          -> 312: "c442"
-120: addition                   -> 192: "add191"
-121: push_constant 2.0          -> 313: "c441"
-122: addition                   -> 191: "add190"
-123: push_constant 2.0          -> 314: "c440"
-124: addition                   -> 190: "add189"
-125: push_constant 2.0          -> 315: "c439"
-126: addition                   -> 189: "add188"
-127: push_constant 2.0          -> 316: "c438"
-128: addition                   -> 188: "add187"
-129: push_constant 2.0          -> 317: "c437"
-130: addition                   -> 187: "add186"
-131: push_constant 2.0          -> 318: "c436"
-132: addition                   -> 186: "add185"
-133: push_constant 2.0          -> 319: "c435"
-134: addition                   -> 185: "add184"
-135: push_constant 2.0          -> 320: "c434"
-136: addition                   -> 184: "add183"
-137: push_constant 2.0          -> 321: "c433"
-138: addition                   -> 183: "add182"
-139: push_constant 2.0          -> 322: "c432"
-140: addition                   -> 182: "add181"
-141: push_constant 2.0          -> 323: "c431"
-142: addition                   -> 181: "add180"
-143: push_constant 2.0          -> 324: "c430"
-144: addition                   -> 180: "add179"
-145: push_constant 2.0          -> 325: "c429"
-146: addition                   -> 179: "add178"
-147: push_constant 2.0          -> 326: "c428"
-148: addition                   -> 178: "add177"
-149: push_constant 2.0          -> 327: "c427"
-150: addition                   -> 177: "add176"
-151: push_constant 2.0          -> 328: "c426"
-152: addition                   -> 176: "add175"
-153: push_constant 2.0          -> 329: "c425"
-154: addition                   -> 175: "add174"
-155: push_constant 2.0          -> 330: "c424"
-156: addition                   -> 174: "add173"
-157: push_constant 2.0          -> 331: "c423"
-158: addition                   -> 173: "add172"
-159: push_constant 2.0          -> 332: "c422"
-160: addition                   -> 172: "add171"
-161: push_constant 2.0          -> 333: "c421"
-162: addition                   -> 171: "add170"
-163: push_constant 2.0          -> 334: "c420"
-164: addition                   -> 170: "add169"
-165: push_constant 2.0          -> 335: "c419"
-166: addition                   -> 169: "add168"
-167: push_constant 2.0          -> 336: "c418"
-168: addition                   -> 168: "add167"
-169: push_constant 2.0          -> 337: "c417"
-170: addition                   -> 167: "add166"
-171: push_constant 2.0          -> 338: "c416"
-172: addition                   -> 166: "add165"
-173: push_constant 2.0          -> 339: "c415"
-174: addition                   -> 165: "add164"
-175: push_constant 2.0          -> 340: "c414"
-176: addition                   -> 164: "add163"
-177: push_constant 2.0          -> 341: "c413"
-178: addition                   -> 163: "add162"
-179: push_constant 2.0          -> 342: "c412"
-180: addition                   -> 162: "add161"
-181: push_constant 2.0          -> 343: "c411"
-182: addition                   -> 161: "add160"
-183: push_constant 2.0          -> 344: "c410"
-184: addition                   -> 160: "add159"
-185: push_constant 2.0          -> 345: "c409"
-186: addition                   -> 159: "add158"
-187: push_constant 2.0          -> 346: "c408"
-188: addition                   -> 158: "add157"
-189: push_constant 2.0          -> 347: "c407"
-190: addition                   -> 157: "add156"
-191: push_constant 2.0          -> 348: "c406"
-192: addition                   -> 156: "add155"
-193: push_constant 2.0          -> 349: "c405"
-194: addition                   -> 155: "add154"
-195: push_constant 2.0          -> 350: "c404"
-196: addition                   -> 154: "add153"
-197: push_constant 2.0          -> 351: "c403"
-198: addition                   -> 153: "add152"
-199: push_constant 2.0          -> 352: "c402"
-200: addition                   -> 152: "add151"
-201: push_constant 2.0          -> 353: "c401"
-202: addition                   -> 151: "add150"
-203: push_constant 2.0          -> 354: "c400"
-204: addition                   -> 150: "add149"
-205: push_constant 2.0          -> 355: "c399"
-206: addition                   -> 149: "add148"
-207: push_constant 2.0          -> 356: "c398"
-208: addition                   -> 148: "add147"
-209: push_constant 2.0          -> 357: "c397"
-210: addition                   -> 147: "add146"
-211: push_constant 2.0          -> 358: "c396"
-212: addition                   -> 146: "add145"
-213: push_constant 2.0          -> 359: "c395"
-214: addition                   -> 145: "add144"
-215: push_constant 2.0          -> 360: "c394"
-216: addition                   -> 144: "add143"
-217: push_constant 2.0          -> 361: "c393"
-218: addition                   -> 143: "add142"
-219: push_constant 2.0          -> 362: "c392"
-220: addition                   -> 142: "add141"
-221: push_constant 2.0          -> 363: "c391"
-222: addition                   -> 141: "add140"
-223: push_constant 2.0          -> 364: "c390"
-224: addition                   -> 140: "add139"
-225: push_constant 2.0          -> 365: "c389"
-226: addition                   -> 139: "add138"
-227: push_constant 2.0          -> 366: "c388"
-228: addition                   -> 138: "add137"
-229: push_constant 2.0          -> 367: "c387"
-230: addition                   -> 137: "add136"
-231: push_constant 2.0          -> 368: "c386"
-232: addition                   -> 136: "add135"
-233: push_constant 2.0          -> 369: "c385"
-234: addition                   -> 135: "add134"
-235: push_constant 2.0          -> 370: "c384"
-236: addition                   -> 134: "add133"
-237: push_constant 2.0          -> 371: "c383"
-238: addition                   -> 133: "add132"
-239: push_constant 2.0          -> 372: "c382"
-240: addition                   -> 132: "add131"
-241: push_constant 2.0          -> 373: "c381"
-242: addition                   -> 131: "add130"
-243: push_constant 2.0          -> 374: "c380"
-244: addition                   -> 130: "add129"
-245: push_constant 2.0          -> 375: "c379"
-246: addition                   -> 129: "add128"
-247: push_constant 2.0          -> 376: "c378"
-248: addition                   -> 128: "add127"
-249: push_constant 2.0          -> 377: "c377"
-250: addition                   -> 127: "add126"
-251: push_constant 2.0          -> 378: "c376"
-252: addition                   -> 126: "add125"
-253: push_constant 2.0          -> 379: "c375"
-254: addition                   -> 125: "add124"
-255: push_constant 2.0          -> 380: "c374"
-256: addition                   -> 124: "add123"
-257: push_constant 2.0          -> 381: "c373"
-258: addition                   -> 123: "add122"
-259: push_constant 2.0          -> 382: "c372"
-260: addition                   -> 122: "add121"
-261: push_constant 2.0          -> 383: "c371"
-262: addition                   -> 121: "add120"
-263: push_constant 2.0          -> 384: "c370"
-264: addition                   -> 120: "add119"
-265: push_constant 2.0          -> 385: "c369"
-266: addition                   -> 119: "add118"
-267: push_constant 2.0          -> 386: "c368"
-268: addition                   -> 118: "add117"
-269: push_constant 2.0          -> 387: "c367"
-270: addition                   -> 117: "add116"
-271: push_constant 2.0          -> 388: "c366"
-272: addition                   -> 116: "add115"
-273: push_constant 2.0          -> 389: "c365"
-274: addition                   -> 115: "add114"
-275: push_constant 2.0          -> 390: "c364"
-276: addition                   -> 114: "add113"
-277: push_constant 2.0          -> 391: "c363"
-278: addition                   -> 113: "add112"
-279: push_constant 2.0          -> 392: "c362"
-280: addition                   -> 112: "add111"
-281: push_constant 2.0          -> 393: "c361"
-282: addition                   -> 111: "add110"
-283: push_constant 2.0          -> 394: "c360"
-284: addition                   -> 110: "add109"
-285: push_constant 2.0          -> 395: "c359"
-286: addition                   -> 109: "add108"
-287: push_constant 2.0          -> 396: "c358"
-288: addition                   -> 108: "add107"
-289: push_constant 2.0          -> 397: "c357"
-290: addition                   -> 107: "add106"
-291: push_constant 2.0          -> 398: "c356"
-292: addition                   -> 106: "add105"
-293: push_constant 2.0          -> 399: "c355"
-294: addition                   -> 105: "add104"
-295: push_constant 2.0          -> 400: "c354"
-296: addition                   -> 104: "add103"
-297: push_constant 2.0          -> 401: "c353"
-298: addition                   -> 103: "add102"
-299: push_constant 2.0          -> 402: "c352"
-300: addition                   -> 102: "add101"
-301: push_constant 2.0          -> 403: "c351"
-302: addition                   -> 101: "add100"
-303: push_constant 2.0          -> 404: "c350"
-304: addition                   -> 100: "add99"
-305: push_constant 2.0          -> 405: "c349"
-306: addition                   -> 99: "add98"
-307: push_constant 2.0          -> 406: "c348"
-308: addition                   -> 98: "add97"
-309: push_constant 2.0          -> 407: "c347"
-310: addition                   -> 97: "add96"
-311: push_constant 2.0          -> 408: "c346"
-312: addition                   -> 96: "add95"
-313: push_constant 2.0          -> 409: "c345"
-314: addition                   -> 95: "add94"
-315: push_constant 2.0          -> 410: "c344"
-316: addition                   -> 94: "add93"
-317: push_constant 2.0          -> 411: "c343"
-318: addition                   -> 93: "add92"
-319: push_constant 2.0          -> 412: "c342"
-320: addition                   -> 92: "add91"
-321: push_constant 2.0          -> 413: "c341"
-322: addition                   -> 91: "add90"
-323: push_constant 2.0          -> 414: "c340"
-324: addition                   -> 90: "add89"
-325: push_constant 2.0          -> 415: "c339"
-326: addition                   -> 89: "add88"
-327: push_constant 2.0          -> 416: "c338"
-328: addition                   -> 88: "add87"
-329: push_constant 2.0          -> 417: "c337"
-330: addition                   -> 87: "add86"
-331: push_constant 2.0          -> 418: "c336"
-332: addition                   -> 86: "add85"
-333: push_constant 2.0          -> 419: "c335"
-334: addition                   -> 85: "add84"
-335: push_constant 2.0          -> 420: "c334"
-336: addition                   -> 84: "add83"
-337: push_constant 2.0          -> 421: "c333"
-338: addition                   -> 83: "add82"
-339: push_constant 2.0          -> 422: "c332"
-340: addition                   -> 82: "add81"
-341: push_constant 2.0          -> 423: "c331"
-342: addition                   -> 81: "add80"
-343: push_constant 2.0          -> 424: "c330"
-344: addition                   -> 80: "add79"
-345: push_constant 2.0          -> 425: "c329"
-346: addition                   -> 79: "add78"
-347: push_constant 2.0          -> 426: "c328"
-348: addition                   -> 78: "add77"
-349: push_constant 2.0          -> 427: "c327"
-350: addition                   -> 77: "add76"
-351: push_constant 2.0          -> 428: "c326"
-352: addition                   -> 76: "add75"
-353: push_constant 2.0          -> 429: "c325"
-354: addition                   -> 75: "add74"
-355: push_constant 2.0          -> 430: "c324"
-356: addition                   -> 74: "add73"
-357: push_constant 2.0          -> 431: "c323"
-358: addition                   -> 73: "add72"
-359: push_constant 2.0          -> 432: "c322"
-360: addition                   -> 72: "add71"
-361: push_constant 2.0          -> 433: "c321"
-362: addition                   -> 71: "add70"
-363: push_constant 2.0          -> 434: "c320"
-364: addition                   -> 70: "add69"
-365: push_constant 2.0          -> 435: "c319"
-366: addition                   -> 69: "add68"
-367: push_constant 2.0          -> 436: "c318"
-368: addition                   -> 68: "add67"
-369: push_constant 2.0          -> 437: "c317"
-370: addition                   -> 67: "add66"
-371: push_constant 2.0          -> 438: "c316"
-372: addition                   -> 66: "add65"
-373: push_constant 2.0          -> 439: "c315"
-374: addition                   -> 65: "add64"
-375: push_constant 2.0          -> 440: "c314"
-376: addition                   -> 64: "add63"
-377: push_constant 2.0          -> 441: "c313"
-378: addition                   -> 63: "add62"
-379: push_constant 2.0          -> 442: "c312"
-380: addition                   -> 62: "add61"
-381: push_constant 2.0          -> 443: "c311"
-382: addition                   -> 61: "add60"
-383: push_constant 2.0          -> 444: "c310"
-384: addition                   -> 60: "add59"
-385: push_constant 2.0          -> 445: "c309"
-386: addition                   -> 59: "add58"
-387: push_constant 2.0          -> 446: "c308"
-388: addition                   -> 58: "add57"
-389: push_constant 2.0          -> 447: "c307"
-390: addition                   -> 57: "add56"
-391: push_constant 2.0          -> 448: "c306"
-392: addition                   -> 56: "add55"
-393: push_constant 2.0          -> 449: "c305"
-394: addition                   -> 55: "add54"
-395: push_constant 2.0          -> 450: "c304"
-396: addition                   -> 54: "add53"
-397: push_constant 2.0          -> 451: "c303"
-398: addition                   -> 53: "add52"
-399: push_constant 2.0          -> 452: "c302"
-400: addition                   -> 52: "add51"
-401: push_constant 2.0          -> 453: "c301"
-402: addition                   -> 51: "add50"
-403: push_constant 2.0          -> 454: "c300"
-404: addition                   -> 50: "add49"
-405: push_constant 2.0          -> 455: "c299"
-406: addition                   -> 49: "add48"
-407: push_constant 2.0          -> 456: "c298"
-408: addition                   -> 48: "add47"
-409: push_constant 2.0          -> 457: "c297"
-410: addition                   -> 47: "add46"
-411: push_constant 2.0          -> 458: "c296"
-412: addition                   -> 46: "add45"
-413: push_constant 2.0          -> 459: "c295"
-414: addition                   -> 45: "add44"
-415: push_constant 2.0          -> 460: "c294"
-416: addition                   -> 44: "add43"
-417: push_constant 2.0          -> 461: "c293"
-418: addition                   -> 43: "add42"
-419: push_constant 2.0          -> 462: "c292"
-420: addition                   -> 42: "add41"
-421: push_constant 2.0          -> 463: "c291"
-422: addition                   -> 41: "add40"
-423: push_constant 2.0          -> 464: "c290"
-424: addition                   -> 40: "add39"
-425: push_constant 2.0          -> 465: "c289"
-426: addition                   -> 39: "add38"
-427: push_constant 2.0          -> 466: "c288"
-428: addition                   -> 38: "add37"
-429: push_constant 2.0          -> 467: "c287"
-430: addition                   -> 37: "add36"
-431: push_constant 2.0          -> 468: "c286"
-432: addition                   -> 36: "add35"
-433: push_constant 2.0          -> 469: "c285"
-434: addition                   -> 35: "add34"
-435: push_constant 2.0          -> 470: "c284"
-436: addition                   -> 34: "add33"
-437: push_constant 2.0          -> 471: "c283"
-438: addition                   -> 33: "add32"
-439: push_constant 2.0          -> 472: "c282"
-440: addition                   -> 32: "add31"
-441: push_constant 2.0          -> 473: "c281"
-442: addition                   -> 31: "add30"
-443: push_constant 2.0          -> 474: "c280"
-444: addition                   -> 30: "add29"
-445: push_constant 2.0          -> 475: "c279"
-446: addition                   -> 29: "add28"
-447: push_constant 2.0          -> 476: "c278"
-448: addition                   -> 28: "add27"
-449: push_constant 2.0          -> 477: "c277"
-450: addition                   -> 27: "add26"
-451: push_constant 2.0          -> 478: "c276"
-452: addition                   -> 26: "add25"
-453: push_constant 2.0          -> 479: "c275"
-454: addition                   -> 25: "add24"
-455: push_constant 2.0          -> 480: "c274"
-456: addition                   -> 24: "add23"
-457: push_constant 2.0          -> 481: "c273"
-458: addition                   -> 23: "add22"
-459: push_constant 2.0          -> 482: "c272"
-460: addition                   -> 22: "add21"
-461: push_constant 2.0          -> 483: "c271"
-462: addition                   -> 21: "add20"
-463: push_constant 2.0          -> 484: "c270"
-464: addition                   -> 20: "add19"
-465: push_constant 2.0          -> 485: "c269"
-466: addition                   -> 19: "add18"
-467: push_constant 2.0          -> 486: "c268"
-468: addition                   -> 18: "add17"
-469: push_constant 2.0          -> 487: "c267"
-470: addition                   -> 17: "add16"
-471: push_constant 2.0          -> 488: "c266"
-472: addition                   -> 16: "add15"
-473: push_constant 2.0          -> 489: "c265"
-474: addition                   -> 15: "add14"
-475: push_constant 2.0          -> 490: "c264"
-476: addition                   -> 14: "add13"
-477: push_constant 2.0          -> 491: "c263"
-478: addition                   -> 13: "add12"
-479: push_constant 2.0          -> 492: "c262"
-480: addition                   -> 12: "add11"
-481: push_constant 2.0          -> 493: "c261"
-482: addition                   -> 11: "add10"
-483: push_constant 2.0          -> 494: "c260"
-484: addition                   -> 10: "add9"
-485: push_constant 2.0          -> 495: "c259"
-486: addition                   -> 9: "add8"
-487: push_constant 2.0          -> 496: "c258"
-488: addition                   -> 8: "add7"
-489: push_constant 2.0          -> 497: "c257"
-490: addition                   -> 7: "add6"
-491: push_constant 2.0          -> 498: "c256"
-492: addition                   -> 6: "add5"
-493: push_constant 2.0          -> 499: "c255"
-494: addition                   -> 5: "add4"
-495: push_constant 2.0          -> 500: "c254"
-496: addition                   -> 4: "add3"
-497: push_constant 2.0          -> 501: "c253"
-498: addition                   -> 3: "add2"
-499: push_constant 2.0          -> 502: "c252"
-500: addition                   -> 2: "add1"
-501: push_constant -1.0         -> 753: "c250"
-502: push_constant 1.0          -> 754: "c251"
-503: subtraction                -> 752: "sub250"
-504: push_constant 2.0          -> 755: "c249"
-505: subtraction                -> 751: "sub249"
-506: push_constant 2.0          -> 756: "c248"
-507: subtraction                -> 750: "sub248"
-508: push_constant 2.0          -> 757: "c247"
-509: subtraction                -> 749: "sub247"
-510: push_constant 2.0          -> 758: "c246"
-511: subtraction                -> 748: "sub246"
-512: push_constant 2.0          -> 759: "c245"
-513: subtraction                -> 747: "sub245"
-514: push_constant 2.0          -> 760: "c244"
-515: subtraction                -> 746: "sub244"
-516: push_constant 2.0          -> 761: "c243"
-517: subtraction                -> 745: "sub243"
-518: push_constant 2.0          -> 762: "c242"
-519: subtraction                -> 744: "sub242"
-520: push_constant 2.0          -> 763: "c241"
-521: subtraction                -> 743: "sub241"
-522: push_constant 2.0          -> 764: "c240"
-523: subtraction                -> 742: "sub240"
-524: push_constant 2.0          -> 765: "c239"
-525: subtraction                -> 741: "sub239"
-526: push_constant 2.0          -> 766: "c238"
-527: subtraction                -> 740: "sub238"
-528: push_constant 2.0          -> 767: "c237"
-529: subtraction                -> 739: "sub237"
-530: push_constant 2.0          -> 768: "c236"
-531: subtraction                -> 738: "sub236"
-532: push_constant 2.0          -> 769: "c235"
-533: subtraction                -> 737: "sub235"
-534: push_constant 2.0          -> 770: "c234"
-535: subtraction                -> 736: "sub234"
-536: push_constant 2.0          -> 771: "c233"
-537: subtraction                -> 735: "sub233"
-538: push_constant 2.0          -> 772: "c232"
-539: subtraction                -> 734: "sub232"
-540: push_constant 2.0          -> 773: "c231"
-541: subtraction                -> 733: "sub231"
-542: push_constant 2.0          -> 774: "c230"
-543: subtraction                -> 732: "sub230"
-544: push_constant 2.0          -> 775: "c229"
-545: subtraction                -> 731: "sub229"
-546: push_constant 2.0          -> 776: "c228"
-547: subtraction                -> 730: "sub228"
-548: push_constant 2.0          -> 777: "c227"
-549: subtraction                -> 729: "sub227"
-550: push_constant 2.0          -> 778: "c226"
-551: subtraction                -> 728: "sub226"
-552: push_constant 2.0          -> 779: "c225"
-553: subtraction                -> 727: "sub225"
-554: push_constant 2.0          -> 780: "c224"
-555: subtraction                -> 726: "sub224"
-556: push_constant 2.0          -> 781: "c223"
-557: subtraction                -> 725: "sub223"
-558: push_constant 2.0          -> 782: "c222"
-559: subtraction                -> 724: "sub222"
-560: push_constant 2.0          -> 783: "c221"
-561: subtraction                -> 723: "sub221"
-562: push_constant 2.0          -> 784: "c220"
-563: subtraction                -> 722: "sub220"
-564: push_constant 2.0          -> 785: "c219"
-565: subtraction                -> 721: "sub219"
-566: push_constant 2.0          -> 786: "c218"
-567: subtraction                -> 720: "sub218"
-568: push_constant 2.0          -> 787: "c217"
-569: subtraction                -> 719: "sub217"
-570: push_constant 2.0          -> 788: "c216"
-571: subtraction                -> 718: "sub216"
-572: push_constant 2.0          -> 789: "c215"
-573: subtraction                -> 717: "sub215"
-574: push_constant 2.0          -> 790: "c214"
-575: subtraction                -> 716: "sub214"
-576: push_constant 2.0          -> 791: "c213"
-577: subtraction                -> 715: "sub213"
-578: push_constant 2.0          -> 792: "c212"
-579: subtraction                -> 714: "sub212"
-580: push_constant 2.0          -> 793: "c211"
-581: subtraction                -> 713: "sub211"
-582: push_constant 2.0          -> 794: "c210"
-583: subtraction                -> 712: "sub210"
-584: push_constant 2.0          -> 795: "c209"
-585: subtraction                -> 711: "sub209"
-586: push_constant 2.0          -> 796: "c208"
-587: subtraction                -> 710: "sub208"
-588: push_constant 2.0          -> 797: "c207"
-589: subtraction                -> 709: "sub207"
-590: push_constant 2.0          -> 798: "c206"
-591: subtraction                -> 708: "sub206"
-592: push_constant 2.0          -> 799: "c205"
-593: subtraction                -> 707: "sub205"
-594: push_constant 2.0          -> 800: "c204"
-595: subtraction                -> 706: "sub204"
-596: push_constant 2.0          -> 801: "c203"
-597: subtraction                -> 705: "sub203"
-598: push_constant 2.0          -> 802: "c202"
-599: subtraction                -> 704: "sub202"
-600: push_constant 2.0          -> 803: "c201"
-601: subtraction                -> 703: "sub201"
-602: push_constant 2.0          -> 804: "c200"
-603: subtraction                -> 702: "sub200"
-604: push_constant 2.0          -> 805: "c199"
-605: subtraction                -> 701: "sub199"
-606: push_constant 2.0          -> 806: "c198"
-607: subtraction                -> 700: "sub198"
-608: push_constant 2.0          -> 807: "c197"
-609: subtraction                -> 699: "sub197"
-610: push_constant 2.0          -> 808: "c196"
-611: subtraction                -> 698: "sub196"
-612: push_constant 2.0          -> 809: "c195"
-613: subtraction                -> 697: "sub195"
-614: push_constant 2.0          -> 810: "c194"
-615: subtraction                -> 696: "sub194"
-616: push_constant 2.0          -> 811: "c193"
-617: subtraction                -> 695: "sub193"
-618: push_constant 2.0          -> 812: "c192"
-619: subtraction                -> 694: "sub192"
-620: push_constant 2.0          -> 813: "c191"
-621: subtraction                -> 693: "sub191"
-622: push_constant 2.0          -> 814: "c190"
-623: subtraction                -> 692: "sub190"
-624: push_constant 2.0          -> 815: "c189"
-625: subtraction                -> 691: "sub189"
-626: push_constant 2.0          -> 816: "c188"
-627: subtraction                -> 690: "sub188"
-628: push_constant 2.0          -> 817: "c187"
-629: subtraction                -> 689: "sub187"
-630: push_constant 2.0          -> 818: "c186"
-631: subtraction                -> 688: "sub186"
-632: push_constant 2.0          -> 819: "c185"
-633: subtraction                -> 687: "sub185"
-634: push_constant 2.0          -> 820: "c184"
-635: subtraction                -> 686: "sub184"
-636: push_constant 2.0          -> 821: "c183"
-637: subtraction                -> 685: "sub183"
-638: push_constant 2.0          -> 822: "c182"
-639: subtraction                -> 684: "sub182"
-640: push_constant 2.0          -> 823: "c181"
-641: subtraction                -> 683: "sub181"
-642: push_constant 2.0          -> 824: "c180"
-643: subtraction                -> 682: "sub180"
-644: push_constant 2.0          -> 825: "c179"
-645: subtraction                -> 681: "sub179"
-646: push_constant 2.0          -> 826: "c178"
-647: subtraction                -> 680: "sub178"
-648: push_constant 2.0          -> 827: "c177"
-649: subtraction                -> 679: "sub177"
-650: push_constant 2.0          -> 828: "c176"
-651: subtraction                -> 678: "sub176"
-652: push_constant 2.0          -> 829: "c175"
-653: subtraction                -> 677: "sub175"
-654: push_constant 2.0          -> 830: "c174"
-655: subtraction                -> 676: "sub174"
-656: push_constant 2.0          -> 831: "c173"
-657: subtraction                -> 675: "sub173"
-658: push_constant 2.0          -> 832: "c172"
-659: subtraction                -> 674: "sub172"
-660: push_constant 2.0          -> 833: "c171"
-661: subtraction                -> 673: "sub171"
-662: push_constant 2.0          -> 834: "c170"
-663: subtraction                -> 672: "sub170"
-664: push_constant 2.0          -> 835: "c169"
-665: subtraction                -> 671: "sub169"
-666: push_constant 2.0          -> 836: "c168"
-667: subtraction                -> 670: "sub168"
-668: push_constant 2.0          -> 837: "c167"
-669: subtraction                -> 669: "sub167"
-670: push_constant 2.0          -> 838: "c166"
-671: subtraction                -> 668: "sub166"
-672: push_constant 2.0          -> 839: "c165"
-673: subtraction                -> 667: "sub165"
-674: push_constant 2.0          -> 840: "c164"
-675: subtraction                -> 666: "sub164"
-676: push_constant 2.0          -> 841: "c163"
-677: subtraction                -> 665: "sub163"
-678: push_constant 2.0          -> 842: "c162"
-679: subtraction                -> 664: "sub162"
-680: push_constant 2.0          -> 843: "c161"
-681: subtraction                -> 663: "sub161"
-682: push_constant 2.0          -> 844: "c160"
-683: subtraction                -> 662: "sub160"
-684: push_constant 2.0          -> 845: "c159"
-685: subtraction                -> 661: "sub159"
-686: push_constant 2.0          -> 846: "c158"
-687: subtraction                -> 660: "sub158"
-688: push_constant 2.0          -> 847: "c157"
-689: subtraction                -> 659: "sub157"
-690: push_constant 2.0          -> 848: "c156"
-691: subtraction                -> 658: "sub156"
-692: push_constant 2.0          -> 849: "c155"
-693: subtraction                -> 657: "sub155"
-694: push_constant 2.0          -> 850: "c154"
-695: subtraction                -> 656: "sub154"
-696: push_constant 2.0          -> 851: "c153"
-697: subtraction                -> 655: "sub153"
-698: push_constant 2.0          -> 852: "c152"
-699: subtraction                -> 654: "sub152"
-700: push_constant 2.0          -> 853: "c151"
-701: subtraction                -> 653: "sub151"
-702: push_constant 2.0          -> 854: "c150"
-703: subtraction                -> 652: "sub150"
-704: push_constant 2.0          -> 855: "c149"
-705: subtraction                -> 651: "sub149"
-706: push_constant 2.0          -> 856: "c148"
-707: subtraction                -> 650: "sub148"
-708: push_constant 2.0          -> 857: "c147"
-709: subtraction                -> 649: "sub147"
-710: push_constant 2.0          -> 858: "c146"
-711: subtraction                -> 648: "sub146"
-712: push_constant 2.0          -> 859: "c145"
-713: subtraction                -> 647: "sub145"
-714: push_constant 2.0          -> 860: "c144"
-715: subtraction                -> 646: "sub144"
-716: push_constant 2.0          -> 861: "c143"
-717: subtraction                -> 645: "sub143"
-718: push_constant 2.0          -> 862: "c142"
-719: subtraction                -> 644: "sub142"
-720: push_constant 2.0          -> 863: "c141"
-721: subtraction                -> 643: "sub141"
-722: push_constant 2.0          -> 864: "c140"
-723: subtraction                -> 642: "sub140"
-724: push_constant 2.0          -> 865: "c139"
-725: subtraction                -> 641: "sub139"
-726: push_constant 2.0          -> 866: "c138"
-727: subtraction                -> 640: "sub138"
-728: push_constant 2.0          -> 867: "c137"
-729: subtraction                -> 639: "sub137"
-730: push_constant 2.0          -> 868: "c136"
-731: subtraction                -> 638: "sub136"
-732: push_constant 2.0          -> 869: "c135"
-733: subtraction                -> 637: "sub135"
-734: push_constant 2.0          -> 870: "c134"
-735: subtraction                -> 636: "sub134"
-736: push_constant 2.0          -> 871: "c133"
-737: subtraction                -> 635: "sub133"
-738: push_constant 2.0          -> 872: "c132"
-739: subtraction                -> 634: "sub132"
-740: push_constant 2.0          -> 873: "c131"
-741: subtraction                -> 633: "sub131"
-742: push_constant 2.0          -> 874: "c130"
-743: subtraction                -> 632: "sub130"
-744: push_constant 2.0          -> 875: "c129"
-745: subtraction                -> 631: "sub129"
-746: push_constant 2.0          -> 876: "c128"
-747: subtraction                -> 630: "sub128"
-748: push_constant 2.0          -> 877: "c127"
-749: subtraction                -> 629: "sub127"
-750: push_constant 2.0          -> 878: "c126"
-751: subtraction                -> 628: "sub126"
-752: push_constant 2.0          -> 879: "c125"
-753: subtraction                -> 627: "sub125"
-754: push_constant 2.0          -> 880: "c124"
-755: subtraction                -> 626: "sub124"
-756: push_constant 2.0          -> 881: "c123"
-757: subtraction                -> 625: "sub123"
-758: push_constant 2.0          -> 882: "c122"
-759: subtraction                -> 624: "sub122"
-760: push_constant 2.0          -> 883: "c121"
-761: subtraction                -> 623: "sub121"
-762: push_constant 2.0          -> 884: "c120"
-763: subtraction                -> 622: "sub120"
-764: push_constant 2.0          -> 885: "c119"
-765: subtraction                -> 621: "sub119"
-766: push_constant 2.0          -> 886: "c118"
-767: subtraction                -> 620: "sub118"
-768: push_constant 2.0          -> 887: "c117"
-769: subtraction                -> 619: "sub117"
-770: push_constant 2.0          -> 888: "c116"
-771: subtraction                -> 618: "sub116"
-772: push_constant 2.0          -> 889: "c115"
-773: subtraction                -> 617: "sub115"
-774: push_constant 2.0          -> 890: "c114"
-775: subtraction                -> 616: "sub114"
-776: push_constant 2.0          -> 891: "c113"
-777: subtraction                -> 615: "sub113"
-778: push_constant 2.0          -> 892: "c112"
-779: subtraction                -> 614: "sub112"
-780: push_constant 2.0          -> 893: "c111"
-781: subtraction                -> 613: "sub111"
-782: push_constant 2.0          -> 894: "c110"
-783: subtraction                -> 612: "sub110"
-784: push_constant 2.0          -> 895: "c109"
-785: subtraction                -> 611: "sub109"
-786: push_constant 2.0          -> 896: "c108"
-787: subtraction                -> 610: "sub108"
-788: push_constant 2.0          -> 897: "c107"
-789: subtraction                -> 609: "sub107"
-790: push_constant 2.0          -> 898: "c106"
-791: subtraction                -> 608: "sub106"
-792: push_constant 2.0          -> 899: "c105"
-793: subtraction                -> 607: "sub105"
-794: push_constant 2.0          -> 900: "c104"
-795: subtraction                -> 606: "sub104"
-796: push_constant 2.0          -> 901: "c103"
-797: subtraction                -> 605: "sub103"
-798: push_constant 2.0          -> 902: "c102"
-799: subtraction                -> 604: "sub102"
-800: push_constant 2.0          -> 903: "c101"
-801: subtraction                -> 603: "sub101"
-802: push_constant 2.0          -> 904: "c100"
-803: subtraction                -> 602: "sub100"
-804: push_constant 2.0          -> 905: "c99"
-805: subtraction                -> 601: "sub99"
-806: push_constant 2.0          -> 906: "c98"
-807: subtraction                -> 600: "sub98"
-808: push_constant 2.0          -> 907: "c97"
-809: subtraction                -> 599: "sub97"
-810: push_constant 2.0          -> 908: "c96"
-811: subtraction                -> 598: "sub96"
-812: push_constant 2.0          -> 909: "c95"
-813: subtraction                -> 597: "sub95"
-814: push_constant 2.0          -> 910: "c94"
-815: subtraction                -> 596: "sub94"
-816: push_constant 2.0          -> 911: "c93"
-817: subtraction                -> 595: "sub93"
-818: push_constant 2.0          -> 912: "c92"
-819: subtraction                -> 594: "sub92"
-820: push_constant 2.0          -> 913: "c91"
-821: subtraction                -> 593: "sub91"
-822: push_constant 2.0          -> 914: "c90"
-823: subtraction                -> 592: "sub90"
-824: push_constant 2.0          -> 915: "c89"
-825: subtraction                -> 591: "sub89"
-826: push_constant 2.0          -> 916: "c88"
-827: subtraction                -> 590: "sub88"
-828: push_constant 2.0          -> 917: "c87"
-829: subtraction                -> 589: "sub87"
-830: push_constant 2.0          -> 918: "c86"
-831: subtraction                -> 588: "sub86"
-832: push_constant 2.0          -> 919: "c85"
-833: subtraction                -> 587: "sub85"
-834: push_constant 2.0          -> 920: "c84"
-835: subtraction                -> 586: "sub84"
-836: push_constant 2.0          -> 921: "c83"
-837: subtraction                -> 585: "sub83"
-838: push_constant 2.0          -> 922: "c82"
-839: subtraction                -> 584: "sub82"
-840: push_constant 2.0          -> 923: "c81"
-841: subtraction                -> 583: "sub81"
-842: push_constant 2.0          -> 924: "c80"
-843: subtraction                -> 582: "sub80"
-844: push_constant 2.0          -> 925: "c79"
-845: subtraction                -> 581: "sub79"
-846: push_constant 2.0          -> 926: "c78"
-847: subtraction                -> 580: "sub78"
-848: push_constant 2.0          -> 927: "c77"
-849: subtraction                -> 579: "sub77"
-850: push_constant 2.0          -> 928: "c76"
-851: subtraction                -> 578: "sub76"
-852: push_constant 2.0          -> 929: "c75"
-853: subtraction                -> 577: "sub75"
-854: push_constant 2.0          -> 930: "c74"
-855: subtraction                -> 576: "sub74"
-856: push_constant 2.0          -> 931: "c73"
-857: subtraction                -> 575: "sub73"
-858: push_constant 2.0          -> 932: "c72"
-859: subtraction                -> 574: "sub72"
-860: push_constant 2.0          -> 933: "c71"
-861: subtraction                -> 573: "sub71"
-862: push_constant 2.0          -> 934: "c70"
-863: subtraction                -> 572: "sub70"
-864: push_constant 2.0          -> 935: "c69"
-865: subtraction                -> 571: "sub69"
-866: push_constant 2.0          -> 936: "c68"
-867: subtraction                -> 570: "sub68"
-868: push_constant 2.0          -> 937: "c67"
-869: subtraction                -> 569: "sub67"
-870: push_constant 2.0          -> 938: "c66"
-871: subtraction                -> 568: "sub66"
-872: push_constant 2.0          -> 939: "c65"
-873: subtraction                -> 567: "sub65"
-874: push_constant 2.0          -> 940: "c64"
-875: subtraction                -> 566: "sub64"
-876: push_constant 2.0          -> 941: "c63"
-877: subtraction                -> 565: "sub63"
-878: push_constant 2.0          -> 942: "c62"
-879: subtraction                -> 564: "sub62"
-880: push_constant 2.0          -> 943: "c61"
-881: subtraction                -> 563: "sub61"
-882: push_constant 2.0          -> 944: "c60"
-883: subtraction                -> 562: "sub60"
-884: push_constant 2.0          -> 945: "c59"
-885: subtraction                -> 561: "sub59"
-886: push_constant 2.0          -> 946: "c58"
-887: subtraction                -> 560: "sub58"
-888: push_constant 2.0          -> 947: "c57"
-889: subtraction                -> 559: "sub57"
-890: push_constant 2.0          -> 948: "c56"
-891: subtraction                -> 558: "sub56"
-892: push_constant 2.0          -> 949: "c55"
-893: subtraction                -> 557: "sub55"
-894: push_constant 2.0          -> 950: "c54"
-895: subtraction                -> 556: "sub54"
-896: push_constant 2.0          -> 951: "c53"
-897: subtraction                -> 555: "sub53"
-898: push_constant 2.0          -> 952: "c52"
-899: subtraction                -> 554: "sub52"
-900: push_constant 2.0          -> 953: "c51"
-901: subtraction                -> 553: "sub51"
-902: push_constant 2.0          -> 954: "c50"
-903: subtraction                -> 552: "sub50"
-904: push_constant 2.0          -> 955: "c49"
-905: subtraction                -> 551: "sub49"
-906: push_constant 2.0          -> 956: "c48"
-907: subtraction                -> 550: "sub48"
-908: push_constant 2.0          -> 957: "c47"
-909: subtraction                -> 549: "sub47"
-910: push_constant 2.0          -> 958: "c46"
-911: subtraction                -> 548: "sub46"
-912: push_constant 2.0          -> 959: "c45"
-913: subtraction                -> 547: "sub45"
-914: push_constant 2.0          -> 960: "c44"
-915: subtraction                -> 546: "sub44"
-916: push_constant 2.0          -> 961: "c43"
-917: subtraction                -> 545: "sub43"
-918: push_constant 2.0          -> 962: "c42"
-919: subtraction                -> 544: "sub42"
-920: push_constant 2.0          -> 963: "c41"
-921: subtraction                -> 543: "sub41"
-922: push_constant 2.0          -> 964: "c40"
-923: subtraction                -> 542: "sub40"
-924: push_constant 2.0          -> 965: "c39"
-925: subtraction                -> 541: "sub39"
-926: push_constant 2.0          -> 966: "c38"
-927: subtraction                -> 540: "sub38"
-928: push_constant 2.0          -> 967: "c37"
-929: subtraction                -> 539: "sub37"
-930: push_constant 2.0          -> 968: "c36"
-931: subtraction                -> 538: "sub36"
-932: push_constant 2.0          -> 969: "c35"
-933: subtraction                -> 537: "sub35"
-934: push_constant 2.0          -> 970: "c34"
-935: subtraction                -> 536: "sub34"
-936: push_constant 2.0          -> 971: "c33"
-937: subtraction                -> 535: "sub33"
-938: push_constant 2.0          -> 972: "c32"
-939: subtraction                -> 534: "sub32"
-940: push_constant 2.0          -> 973: "c31"
-941: subtraction                -> 533: "sub31"
-942: push_constant 2.0          -> 974: "c30"
-943: subtraction                -> 532: "sub30"
-944: push_constant 2.0          -> 975: "c29"
-945: subtraction                -> 531: "sub29"
-946: push_constant 2.0          -> 976: "c28"
-947: subtraction                -> 530: "sub28"
-948: push_constant 2.0          -> 977: "c27"
-949: subtraction                -> 529: "sub27"
-950: push_constant 2.0          -> 978: "c26"
-951: subtraction                -> 528: "sub26"
-952: push_constant 2.0          -> 979: "c25"
-953: subtraction                -> 527: "sub25"
-954: push_constant 2.0          -> 980: "c24"
-955: subtraction                -> 526: "sub24"
-956: push_constant 2.0          -> 981: "c23"
-957: subtraction                -> 525: "sub23"
-958: push_constant 2.0          -> 982: "c22"
-959: subtraction                -> 524: "sub22"
-960: push_constant 2.0          -> 983: "c21"
-961: subtraction                -> 523: "sub21"
-962: push_constant 2.0          -> 984: "c20"
-963: subtraction                -> 522: "sub20"
-964: push_constant 2.0          -> 985: "c19"
-965: subtraction                -> 521: "sub19"
-966: push_constant 2.0          -> 986: "c18"
-967: subtraction                -> 520: "sub18"
-968: push_constant 2.0          -> 987: "c17"
-969: subtraction                -> 519: "sub17"
-970: push_constant 2.0          -> 988: "c16"
-971: subtraction                -> 518: "sub16"
-972: push_constant 2.0          -> 989: "c15"
-973: subtraction                -> 517: "sub15"
-974: push_constant 2.0          -> 990: "c14"
-975: subtraction                -> 516: "sub14"
-976: push_constant 2.0          -> 991: "c13"
-977: subtraction                -> 515: "sub13"
-978: push_constant 2.0          -> 992: "c12"
-979: subtraction                -> 514: "sub12"
-980: push_constant 2.0          -> 993: "c11"
-981: subtraction                -> 513: "sub11"
-982: push_constant 2.0          -> 994: "c10"
-983: subtraction                -> 512: "sub10"
-984: push_constant 2.0          -> 995: "c9"
-985: subtraction                -> 511: "sub9"
-986: push_constant 2.0          -> 996: "c8"
-987: subtraction                -> 510: "sub8"
-988: push_constant 2.0          -> 997: "c7"
-989: subtraction                -> 509: "sub7"
-990: push_constant 2.0          -> 998: "c6"
-991: subtraction                -> 508: "sub6"
-992: push_constant 2.0          -> 999: "c5"
-993: subtraction                -> 507: "sub5"
-994: push_constant 2.0          -> 1000: "c4"
-995: subtraction                -> 506: "sub4"
-996: push_constant 2.0          -> 1001: "c3"
-997: subtraction                -> 505: "sub3"
-998: push_constant 2.0          -> 1002: "c2"
-999: subtraction                -> 504: "sub2"
-1000: push_constant 2.0          -> 1003: "c1"
-1001: subtraction                -> 503: "sub1"
-1002: addition                   -> 1: "bfly1.0"
-1003: forward_value              -> 0: "0"
-1004: push_result results[2]     -> 2: "add1"
-1005: push_result results[503]   -> 503: "sub1"
-1006: subtraction                -> 1005: "bfly1.1"
-1007: forward_value              -> 1004: "1"
-==============================================
-
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
-simulation.cpp:72                       : Running simulation iteration.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating push_constant -1.0.
-run.cpp:80                              : Evaluating push_constant 1.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating push_constant 2.0.
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating addition.
-run.cpp:80                              : Evaluating forward_value.
-run.cpp:80                              : Evaluating push_result results[2].
-run.cpp:80                              : Evaluating push_result results[503].
-run.cpp:80                              : Evaluating subtraction.
-run.cpp:80                              : Evaluating forward_value.
diff --git a/test/test_simulation.py b/test/test_simulation.py
index 89a800ad..8ca19e47 100644
--- a/test/test_simulation.py
+++ b/test/test_simulation.py
@@ -1,11 +1,7 @@
 import pytest
 import numpy as np
 
-<<<<<<< HEAD
-from b_asic import SFG, Input, Output, Delay, ConstantMultiplication, Simulation
-=======
-from b_asic import SFG, Simulation
->>>>>>> d2ae5743259f581c116bb3772d17c3b2023ed9e0
+from b_asic import SFG, Output, Simulation
 
 
 class TestRunFor:
@@ -126,17 +122,11 @@ class TestRunFor:
         assert simulation.results["0"][4] == -6
         assert simulation.results["0"][5] == 7
 
-    def test_find_result_key(self):
-        indata = [77, 99, 0.3, 23, 88, 3.14, 4.76, 45, 0.099]
-        i = Input()
-        d = Delay()
-        m = ConstantMultiplication(0.5, d, "Mult")
-        d << (m + i)
-        o = Output(d)
-        s = SFG(inputs=[i], outputs=[o])
-        sim = Simulation(s, [indata])
+    def test_find_result_key(self, precedence_sfg_delays):
+        sim = Simulation(precedence_sfg_delays, [[0, 4, 542, 42, 31.314, 534.123, -453415, 5431]])
         sim.run()
-        assert sim.results[s.find_result_keys_by_name("Mult")[0]][4] == 0.35
+        assert sim.results[precedence_sfg_delays.find_result_keys_by_name("ADD2")[0]][4] == 31220
+        assert sim.results[precedence_sfg_delays.find_result_keys_by_name("A1")[0]][2] == 80
 
 class TestRun:
     def test_save_results(self, sfg_two_inputs_two_outputs):
-- 
GitLab